var __getOwnPropNames = Object.getOwnPropertyNames;
var __require = /* @__PURE__ */ ((x) =>
  typeof require !== "undefined"
    ? require
    : typeof Proxy !== "undefined"
    ? new Proxy(x, {
        get: (a, b) => (typeof require !== "undefined" ? require : a)[b],
      })
    : x)(function (x) {
  if (typeof require !== "undefined") return require.apply(this, arguments);
  throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) =>
  function __require2() {
    return (
      mod ||
        (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod),
      mod.exports
    );
  };

// node_modules/html-docx-js/dist/html-docx.js
var require_html_docx = __commonJS({
  "node_modules/html-docx-js/dist/html-docx.js"(exports, module) {
    !(function (e) {
      if ("object" == typeof exports && "undefined" != typeof module)
        module.exports = e();
      else if ("function" == typeof define && define.amd) define([], e);
      else {
        var f;
        "undefined" != typeof window
          ? (f = window)
          : "undefined" != typeof global
          ? (f = global)
          : "undefined" != typeof self && (f = self),
          (f.htmlDocx = e());
      }
    })(function () {
      var define2, module2, exports2;
      return (function e(t, n, r) {
        function s(o2, u) {
          if (!n[o2]) {
            if (!t[o2]) {
              var a = typeof __require == "function" && __require;
              if (!u && a) return a(o2, true);
              if (i) return i(o2, true);
              throw new Error("Cannot find module '" + o2 + "'");
            }
            var f = (n[o2] = { exports: {} });
            t[o2][0].call(
              f.exports,
              function (e2) {
                var n2 = t[o2][1][e2];
                return s(n2 ? n2 : e2);
              },
              f,
              f.exports,
              e,
              t,
              n,
              r
            );
          }
          return n[o2].exports;
        }
        var i = typeof __require == "function" && __require;
        for (var o = 0; o < r.length; o++) s(r[o]);
        return s;
      })(
        {
          1: [
            function (_dereq_, module3, exports3) {
              var base64 = _dereq_("base64-js");
              var ieee754 = _dereq_("ieee754");
              var isArray = _dereq_("is-array");
              exports3.Buffer = Buffer;
              exports3.SlowBuffer = Buffer;
              exports3.INSPECT_MAX_BYTES = 50;
              Buffer.poolSize = 8192;
              var kMaxLength = 1073741823;
              Buffer.TYPED_ARRAY_SUPPORT = (function () {
                try {
                  var buf = new ArrayBuffer(0);
                  var arr = new Uint8Array(buf);
                  arr.foo = function () {
                    return 42;
                  };
                  return (
                    42 === arr.foo() && // typed array instances can be augmented
                    typeof arr.subarray === "function" && // chrome 9-10 lack `subarray`
                    new Uint8Array(1).subarray(1, 1).byteLength === 0
                  );
                } catch (e) {
                  return false;
                }
              })();
              function Buffer(subject, encoding, noZero) {
                if (!(this instanceof Buffer))
                  return new Buffer(subject, encoding, noZero);
                var type = typeof subject;
                var length;
                if (type === "number") length = subject > 0 ? subject >>> 0 : 0;
                else if (type === "string") {
                  if (encoding === "base64") subject = base64clean(subject);
                  length = Buffer.byteLength(subject, encoding);
                } else if (type === "object" && subject !== null) {
                  if (subject.type === "Buffer" && isArray(subject.data))
                    subject = subject.data;
                  length =
                    +subject.length > 0 ? Math.floor(+subject.length) : 0;
                } else
                  throw new TypeError(
                    "must start with number, buffer, array or string"
                  );
                if (this.length > kMaxLength)
                  throw new RangeError(
                    "Attempt to allocate Buffer larger than maximum size: 0x" +
                      kMaxLength.toString(16) +
                      " bytes"
                  );
                var buf;
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  buf = Buffer._augment(new Uint8Array(length));
                } else {
                  buf = this;
                  buf.length = length;
                  buf._isBuffer = true;
                }
                var i;
                if (
                  Buffer.TYPED_ARRAY_SUPPORT &&
                  typeof subject.byteLength === "number"
                ) {
                  buf._set(subject);
                } else if (isArrayish(subject)) {
                  if (Buffer.isBuffer(subject)) {
                    for (i = 0; i < length; i++) buf[i] = subject.readUInt8(i);
                  } else {
                    for (i = 0; i < length; i++)
                      buf[i] = ((subject[i] % 256) + 256) % 256;
                  }
                } else if (type === "string") {
                  buf.write(subject, 0, encoding);
                } else if (
                  type === "number" &&
                  !Buffer.TYPED_ARRAY_SUPPORT &&
                  !noZero
                ) {
                  for (i = 0; i < length; i++) {
                    buf[i] = 0;
                  }
                }
                return buf;
              }
              Buffer.isBuffer = function (b) {
                return !!(b != null && b._isBuffer);
              };
              Buffer.compare = function (a, b) {
                if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
                  throw new TypeError("Arguments must be Buffers");
                var x = a.length;
                var y = b.length;
                for (
                  var i = 0, len = Math.min(x, y);
                  i < len && a[i] === b[i];
                  i++
                ) {}
                if (i !== len) {
                  x = a[i];
                  y = b[i];
                }
                if (x < y) return -1;
                if (y < x) return 1;
                return 0;
              };
              Buffer.isEncoding = function (encoding) {
                switch (String(encoding).toLowerCase()) {
                  case "hex":
                  case "utf8":
                  case "utf-8":
                  case "ascii":
                  case "binary":
                  case "base64":
                  case "raw":
                  case "ucs2":
                  case "ucs-2":
                  case "utf16le":
                  case "utf-16le":
                    return true;
                  default:
                    return false;
                }
              };
              Buffer.concat = function (list, totalLength) {
                if (!isArray(list))
                  throw new TypeError("Usage: Buffer.concat(list[, length])");
                if (list.length === 0) {
                  return new Buffer(0);
                } else if (list.length === 1) {
                  return list[0];
                }
                var i;
                if (totalLength === void 0) {
                  totalLength = 0;
                  for (i = 0; i < list.length; i++) {
                    totalLength += list[i].length;
                  }
                }
                var buf = new Buffer(totalLength);
                var pos = 0;
                for (i = 0; i < list.length; i++) {
                  var item = list[i];
                  item.copy(buf, pos);
                  pos += item.length;
                }
                return buf;
              };
              Buffer.byteLength = function (str, encoding) {
                var ret;
                str = str + "";
                switch (encoding || "utf8") {
                  case "ascii":
                  case "binary":
                  case "raw":
                    ret = str.length;
                    break;
                  case "ucs2":
                  case "ucs-2":
                  case "utf16le":
                  case "utf-16le":
                    ret = str.length * 2;
                    break;
                  case "hex":
                    ret = str.length >>> 1;
                    break;
                  case "utf8":
                  case "utf-8":
                    ret = utf8ToBytes(str).length;
                    break;
                  case "base64":
                    ret = base64ToBytes(str).length;
                    break;
                  default:
                    ret = str.length;
                }
                return ret;
              };
              Buffer.prototype.length = void 0;
              Buffer.prototype.parent = void 0;
              Buffer.prototype.toString = function (encoding, start, end) {
                var loweredCase = false;
                start = start >>> 0;
                end =
                  end === void 0 || end === Infinity ? this.length : end >>> 0;
                if (!encoding) encoding = "utf8";
                if (start < 0) start = 0;
                if (end > this.length) end = this.length;
                if (end <= start) return "";
                while (true) {
                  switch (encoding) {
                    case "hex":
                      return hexSlice(this, start, end);
                    case "utf8":
                    case "utf-8":
                      return utf8Slice(this, start, end);
                    case "ascii":
                      return asciiSlice(this, start, end);
                    case "binary":
                      return binarySlice(this, start, end);
                    case "base64":
                      return base64Slice(this, start, end);
                    case "ucs2":
                    case "ucs-2":
                    case "utf16le":
                    case "utf-16le":
                      return utf16leSlice(this, start, end);
                    default:
                      if (loweredCase)
                        throw new TypeError("Unknown encoding: " + encoding);
                      encoding = (encoding + "").toLowerCase();
                      loweredCase = true;
                  }
                }
              };
              Buffer.prototype.equals = function (b) {
                if (!Buffer.isBuffer(b))
                  throw new TypeError("Argument must be a Buffer");
                return Buffer.compare(this, b) === 0;
              };
              Buffer.prototype.inspect = function () {
                var str = "";
                var max = exports3.INSPECT_MAX_BYTES;
                if (this.length > 0) {
                  str = this.toString("hex", 0, max).match(/.{2}/g).join(" ");
                  if (this.length > max) str += " ... ";
                }
                return "<Buffer " + str + ">";
              };
              Buffer.prototype.compare = function (b) {
                if (!Buffer.isBuffer(b))
                  throw new TypeError("Argument must be a Buffer");
                return Buffer.compare(this, b);
              };
              Buffer.prototype.get = function (offset) {
                console.log(
                  ".get() is deprecated. Access using array indexes instead."
                );
                return this.readUInt8(offset);
              };
              Buffer.prototype.set = function (v, offset) {
                console.log(
                  ".set() is deprecated. Access using array indexes instead."
                );
                return this.writeUInt8(v, offset);
              };
              function hexWrite(buf, string, offset, length) {
                offset = Number(offset) || 0;
                var remaining = buf.length - offset;
                if (!length) {
                  length = remaining;
                } else {
                  length = Number(length);
                  if (length > remaining) {
                    length = remaining;
                  }
                }
                var strLen = string.length;
                if (strLen % 2 !== 0) throw new Error("Invalid hex string");
                if (length > strLen / 2) {
                  length = strLen / 2;
                }
                for (var i = 0; i < length; i++) {
                  var byte = parseInt(string.substr(i * 2, 2), 16);
                  if (isNaN(byte)) throw new Error("Invalid hex string");
                  buf[offset + i] = byte;
                }
                return i;
              }
              function utf8Write(buf, string, offset, length) {
                var charsWritten = blitBuffer(
                  utf8ToBytes(string),
                  buf,
                  offset,
                  length
                );
                return charsWritten;
              }
              function asciiWrite(buf, string, offset, length) {
                var charsWritten = blitBuffer(
                  asciiToBytes(string),
                  buf,
                  offset,
                  length
                );
                return charsWritten;
              }
              function binaryWrite(buf, string, offset, length) {
                return asciiWrite(buf, string, offset, length);
              }
              function base64Write(buf, string, offset, length) {
                var charsWritten = blitBuffer(
                  base64ToBytes(string),
                  buf,
                  offset,
                  length
                );
                return charsWritten;
              }
              function utf16leWrite(buf, string, offset, length) {
                var charsWritten = blitBuffer(
                  utf16leToBytes(string),
                  buf,
                  offset,
                  length,
                  2
                );
                return charsWritten;
              }
              Buffer.prototype.write = function (
                string,
                offset,
                length,
                encoding
              ) {
                if (isFinite(offset)) {
                  if (!isFinite(length)) {
                    encoding = length;
                    length = void 0;
                  }
                } else {
                  var swap = encoding;
                  encoding = offset;
                  offset = length;
                  length = swap;
                }
                offset = Number(offset) || 0;
                var remaining = this.length - offset;
                if (!length) {
                  length = remaining;
                } else {
                  length = Number(length);
                  if (length > remaining) {
                    length = remaining;
                  }
                }
                encoding = String(encoding || "utf8").toLowerCase();
                var ret;
                switch (encoding) {
                  case "hex":
                    ret = hexWrite(this, string, offset, length);
                    break;
                  case "utf8":
                  case "utf-8":
                    ret = utf8Write(this, string, offset, length);
                    break;
                  case "ascii":
                    ret = asciiWrite(this, string, offset, length);
                    break;
                  case "binary":
                    ret = binaryWrite(this, string, offset, length);
                    break;
                  case "base64":
                    ret = base64Write(this, string, offset, length);
                    break;
                  case "ucs2":
                  case "ucs-2":
                  case "utf16le":
                  case "utf-16le":
                    ret = utf16leWrite(this, string, offset, length);
                    break;
                  default:
                    throw new TypeError("Unknown encoding: " + encoding);
                }
                return ret;
              };
              Buffer.prototype.toJSON = function () {
                return {
                  type: "Buffer",
                  data: Array.prototype.slice.call(this._arr || this, 0),
                };
              };
              function base64Slice(buf, start, end) {
                if (start === 0 && end === buf.length) {
                  return base64.fromByteArray(buf);
                } else {
                  return base64.fromByteArray(buf.slice(start, end));
                }
              }
              function utf8Slice(buf, start, end) {
                var res = "";
                var tmp = "";
                end = Math.min(buf.length, end);
                for (var i = start; i < end; i++) {
                  if (buf[i] <= 127) {
                    res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]);
                    tmp = "";
                  } else {
                    tmp += "%" + buf[i].toString(16);
                  }
                }
                return res + decodeUtf8Char(tmp);
              }
              function asciiSlice(buf, start, end) {
                var ret = "";
                end = Math.min(buf.length, end);
                for (var i = start; i < end; i++) {
                  ret += String.fromCharCode(buf[i]);
                }
                return ret;
              }
              function binarySlice(buf, start, end) {
                return asciiSlice(buf, start, end);
              }
              function hexSlice(buf, start, end) {
                var len = buf.length;
                if (!start || start < 0) start = 0;
                if (!end || end < 0 || end > len) end = len;
                var out = "";
                for (var i = start; i < end; i++) {
                  out += toHex(buf[i]);
                }
                return out;
              }
              function utf16leSlice(buf, start, end) {
                var bytes = buf.slice(start, end);
                var res = "";
                for (var i = 0; i < bytes.length; i += 2) {
                  res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
                }
                return res;
              }
              Buffer.prototype.slice = function (start, end) {
                var len = this.length;
                start = ~~start;
                end = end === void 0 ? len : ~~end;
                if (start < 0) {
                  start += len;
                  if (start < 0) start = 0;
                } else if (start > len) {
                  start = len;
                }
                if (end < 0) {
                  end += len;
                  if (end < 0) end = 0;
                } else if (end > len) {
                  end = len;
                }
                if (end < start) end = start;
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  return Buffer._augment(this.subarray(start, end));
                } else {
                  var sliceLen = end - start;
                  var newBuf = new Buffer(sliceLen, void 0, true);
                  for (var i = 0; i < sliceLen; i++) {
                    newBuf[i] = this[i + start];
                  }
                  return newBuf;
                }
              };
              function checkOffset(offset, ext, length) {
                if (offset % 1 !== 0 || offset < 0)
                  throw new RangeError("offset is not uint");
                if (offset + ext > length)
                  throw new RangeError("Trying to access beyond buffer length");
              }
              Buffer.prototype.readUInt8 = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length);
                return this[offset];
              };
              Buffer.prototype.readUInt16LE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                return this[offset] | (this[offset + 1] << 8);
              };
              Buffer.prototype.readUInt16BE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                return (this[offset] << 8) | this[offset + 1];
              };
              Buffer.prototype.readUInt32LE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return (
                  (this[offset] |
                    (this[offset + 1] << 8) |
                    (this[offset + 2] << 16)) +
                  this[offset + 3] * 16777216
                );
              };
              Buffer.prototype.readUInt32BE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return (
                  this[offset] * 16777216 +
                  ((this[offset + 1] << 16) |
                    (this[offset + 2] << 8) |
                    this[offset + 3])
                );
              };
              Buffer.prototype.readInt8 = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length);
                if (!(this[offset] & 128)) return this[offset];
                return (255 - this[offset] + 1) * -1;
              };
              Buffer.prototype.readInt16LE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                var val = this[offset] | (this[offset + 1] << 8);
                return val & 32768 ? val | 4294901760 : val;
              };
              Buffer.prototype.readInt16BE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                var val = this[offset + 1] | (this[offset] << 8);
                return val & 32768 ? val | 4294901760 : val;
              };
              Buffer.prototype.readInt32LE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return (
                  this[offset] |
                  (this[offset + 1] << 8) |
                  (this[offset + 2] << 16) |
                  (this[offset + 3] << 24)
                );
              };
              Buffer.prototype.readInt32BE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return (
                  (this[offset] << 24) |
                  (this[offset + 1] << 16) |
                  (this[offset + 2] << 8) |
                  this[offset + 3]
                );
              };
              Buffer.prototype.readFloatLE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return ieee754.read(this, offset, true, 23, 4);
              };
              Buffer.prototype.readFloatBE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return ieee754.read(this, offset, false, 23, 4);
              };
              Buffer.prototype.readDoubleLE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length);
                return ieee754.read(this, offset, true, 52, 8);
              };
              Buffer.prototype.readDoubleBE = function (offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length);
                return ieee754.read(this, offset, false, 52, 8);
              };
              function checkInt(buf, value, offset, ext, max, min) {
                if (!Buffer.isBuffer(buf))
                  throw new TypeError("buffer must be a Buffer instance");
                if (value > max || value < min)
                  throw new TypeError("value is out of bounds");
                if (offset + ext > buf.length)
                  throw new TypeError("index out of range");
              }
              Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
                this[offset] = value;
                return offset + 1;
              };
              function objectWriteUInt16(buf, value, offset, littleEndian) {
                if (value < 0) value = 65535 + value + 1;
                for (
                  var i = 0, j = Math.min(buf.length - offset, 2);
                  i < j;
                  i++
                ) {
                  buf[offset + i] =
                    (value & (255 << (8 * (littleEndian ? i : 1 - i)))) >>>
                    ((littleEndian ? i : 1 - i) * 8);
                }
              }
              Buffer.prototype.writeUInt16LE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value;
                  this[offset + 1] = value >>> 8;
                } else objectWriteUInt16(this, value, offset, true);
                return offset + 2;
              };
              Buffer.prototype.writeUInt16BE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value >>> 8;
                  this[offset + 1] = value;
                } else objectWriteUInt16(this, value, offset, false);
                return offset + 2;
              };
              function objectWriteUInt32(buf, value, offset, littleEndian) {
                if (value < 0) value = 4294967295 + value + 1;
                for (
                  var i = 0, j = Math.min(buf.length - offset, 4);
                  i < j;
                  i++
                ) {
                  buf[offset + i] =
                    (value >>> ((littleEndian ? i : 3 - i) * 8)) & 255;
                }
              }
              Buffer.prototype.writeUInt32LE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset + 3] = value >>> 24;
                  this[offset + 2] = value >>> 16;
                  this[offset + 1] = value >>> 8;
                  this[offset] = value;
                } else objectWriteUInt32(this, value, offset, true);
                return offset + 4;
              };
              Buffer.prototype.writeUInt32BE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value >>> 24;
                  this[offset + 1] = value >>> 16;
                  this[offset + 2] = value >>> 8;
                  this[offset + 3] = value;
                } else objectWriteUInt32(this, value, offset, false);
                return offset + 4;
              };
              Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
                if (value < 0) value = 255 + value + 1;
                this[offset] = value;
                return offset + 1;
              };
              Buffer.prototype.writeInt16LE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value;
                  this[offset + 1] = value >>> 8;
                } else objectWriteUInt16(this, value, offset, true);
                return offset + 2;
              };
              Buffer.prototype.writeInt16BE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value >>> 8;
                  this[offset + 1] = value;
                } else objectWriteUInt16(this, value, offset, false);
                return offset + 2;
              };
              Buffer.prototype.writeInt32LE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert)
                  checkInt(this, value, offset, 4, 2147483647, -2147483648);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value;
                  this[offset + 1] = value >>> 8;
                  this[offset + 2] = value >>> 16;
                  this[offset + 3] = value >>> 24;
                } else objectWriteUInt32(this, value, offset, true);
                return offset + 4;
              };
              Buffer.prototype.writeInt32BE = function (
                value,
                offset,
                noAssert
              ) {
                value = +value;
                offset = offset >>> 0;
                if (!noAssert)
                  checkInt(this, value, offset, 4, 2147483647, -2147483648);
                if (value < 0) value = 4294967295 + value + 1;
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                  this[offset] = value >>> 24;
                  this[offset + 1] = value >>> 16;
                  this[offset + 2] = value >>> 8;
                  this[offset + 3] = value;
                } else objectWriteUInt32(this, value, offset, false);
                return offset + 4;
              };
              function checkIEEE754(buf, value, offset, ext, max, min) {
                if (value > max || value < min)
                  throw new TypeError("value is out of bounds");
                if (offset + ext > buf.length)
                  throw new TypeError("index out of range");
              }
              function writeFloat(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert)
                  checkIEEE754(
                    buf,
                    value,
                    offset,
                    4,
                    34028234663852886e22,
                    -34028234663852886e22
                  );
                ieee754.write(buf, value, offset, littleEndian, 23, 4);
                return offset + 4;
              }
              Buffer.prototype.writeFloatLE = function (
                value,
                offset,
                noAssert
              ) {
                return writeFloat(this, value, offset, true, noAssert);
              };
              Buffer.prototype.writeFloatBE = function (
                value,
                offset,
                noAssert
              ) {
                return writeFloat(this, value, offset, false, noAssert);
              };
              function writeDouble(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert)
                  checkIEEE754(
                    buf,
                    value,
                    offset,
                    8,
                    17976931348623157e292,
                    -17976931348623157e292
                  );
                ieee754.write(buf, value, offset, littleEndian, 52, 8);
                return offset + 8;
              }
              Buffer.prototype.writeDoubleLE = function (
                value,
                offset,
                noAssert
              ) {
                return writeDouble(this, value, offset, true, noAssert);
              };
              Buffer.prototype.writeDoubleBE = function (
                value,
                offset,
                noAssert
              ) {
                return writeDouble(this, value, offset, false, noAssert);
              };
              Buffer.prototype.copy = function (
                target,
                target_start,
                start,
                end
              ) {
                var source = this;
                if (!start) start = 0;
                if (!end && end !== 0) end = this.length;
                if (!target_start) target_start = 0;
                if (end === start) return;
                if (target.length === 0 || source.length === 0) return;
                if (end < start) throw new TypeError("sourceEnd < sourceStart");
                if (target_start < 0 || target_start >= target.length)
                  throw new TypeError("targetStart out of bounds");
                if (start < 0 || start >= source.length)
                  throw new TypeError("sourceStart out of bounds");
                if (end < 0 || end > source.length)
                  throw new TypeError("sourceEnd out of bounds");
                if (end > this.length) end = this.length;
                if (target.length - target_start < end - start)
                  end = target.length - target_start + start;
                var len = end - start;
                if (len < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT) {
                  for (var i = 0; i < len; i++) {
                    target[i + target_start] = this[i + start];
                  }
                } else {
                  target._set(this.subarray(start, start + len), target_start);
                }
              };
              Buffer.prototype.fill = function (value, start, end) {
                if (!value) value = 0;
                if (!start) start = 0;
                if (!end) end = this.length;
                if (end < start) throw new TypeError("end < start");
                if (end === start) return;
                if (this.length === 0) return;
                if (start < 0 || start >= this.length)
                  throw new TypeError("start out of bounds");
                if (end < 0 || end > this.length)
                  throw new TypeError("end out of bounds");
                var i;
                if (typeof value === "number") {
                  for (i = start; i < end; i++) {
                    this[i] = value;
                  }
                } else {
                  var bytes = utf8ToBytes(value.toString());
                  var len = bytes.length;
                  for (i = start; i < end; i++) {
                    this[i] = bytes[i % len];
                  }
                }
                return this;
              };
              Buffer.prototype.toArrayBuffer = function () {
                if (typeof Uint8Array !== "undefined") {
                  if (Buffer.TYPED_ARRAY_SUPPORT) {
                    return new Buffer(this).buffer;
                  } else {
                    var buf = new Uint8Array(this.length);
                    for (var i = 0, len = buf.length; i < len; i += 1) {
                      buf[i] = this[i];
                    }
                    return buf.buffer;
                  }
                } else {
                  throw new TypeError(
                    "Buffer.toArrayBuffer not supported in this browser"
                  );
                }
              };
              var BP = Buffer.prototype;
              Buffer._augment = function (arr) {
                arr.constructor = Buffer;
                arr._isBuffer = true;
                arr._get = arr.get;
                arr._set = arr.set;
                arr.get = BP.get;
                arr.set = BP.set;
                arr.write = BP.write;
                arr.toString = BP.toString;
                arr.toLocaleString = BP.toString;
                arr.toJSON = BP.toJSON;
                arr.equals = BP.equals;
                arr.compare = BP.compare;
                arr.copy = BP.copy;
                arr.slice = BP.slice;
                arr.readUInt8 = BP.readUInt8;
                arr.readUInt16LE = BP.readUInt16LE;
                arr.readUInt16BE = BP.readUInt16BE;
                arr.readUInt32LE = BP.readUInt32LE;
                arr.readUInt32BE = BP.readUInt32BE;
                arr.readInt8 = BP.readInt8;
                arr.readInt16LE = BP.readInt16LE;
                arr.readInt16BE = BP.readInt16BE;
                arr.readInt32LE = BP.readInt32LE;
                arr.readInt32BE = BP.readInt32BE;
                arr.readFloatLE = BP.readFloatLE;
                arr.readFloatBE = BP.readFloatBE;
                arr.readDoubleLE = BP.readDoubleLE;
                arr.readDoubleBE = BP.readDoubleBE;
                arr.writeUInt8 = BP.writeUInt8;
                arr.writeUInt16LE = BP.writeUInt16LE;
                arr.writeUInt16BE = BP.writeUInt16BE;
                arr.writeUInt32LE = BP.writeUInt32LE;
                arr.writeUInt32BE = BP.writeUInt32BE;
                arr.writeInt8 = BP.writeInt8;
                arr.writeInt16LE = BP.writeInt16LE;
                arr.writeInt16BE = BP.writeInt16BE;
                arr.writeInt32LE = BP.writeInt32LE;
                arr.writeInt32BE = BP.writeInt32BE;
                arr.writeFloatLE = BP.writeFloatLE;
                arr.writeFloatBE = BP.writeFloatBE;
                arr.writeDoubleLE = BP.writeDoubleLE;
                arr.writeDoubleBE = BP.writeDoubleBE;
                arr.fill = BP.fill;
                arr.inspect = BP.inspect;
                arr.toArrayBuffer = BP.toArrayBuffer;
                return arr;
              };
              var INVALID_BASE64_RE = /[^+\/0-9A-z]/g;
              function base64clean(str) {
                str = stringtrim(str).replace(INVALID_BASE64_RE, "");
                while (str.length % 4 !== 0) {
                  str = str + "=";
                }
                return str;
              }
              function stringtrim(str) {
                if (str.trim) return str.trim();
                return str.replace(/^\s+|\s+$/g, "");
              }
              function isArrayish(subject) {
                return (
                  isArray(subject) ||
                  Buffer.isBuffer(subject) ||
                  (subject &&
                    typeof subject === "object" &&
                    typeof subject.length === "number")
                );
              }
              function toHex(n) {
                if (n < 16) return "0" + n.toString(16);
                return n.toString(16);
              }
              function utf8ToBytes(str) {
                var byteArray = [];
                for (var i = 0; i < str.length; i++) {
                  var b = str.charCodeAt(i);
                  if (b <= 127) {
                    byteArray.push(b);
                  } else {
                    var start = i;
                    if (b >= 55296 && b <= 57343) i++;
                    var h = encodeURIComponent(str.slice(start, i + 1))
                      .substr(1)
                      .split("%");
                    for (var j = 0; j < h.length; j++) {
                      byteArray.push(parseInt(h[j], 16));
                    }
                  }
                }
                return byteArray;
              }
              function asciiToBytes(str) {
                var byteArray = [];
                for (var i = 0; i < str.length; i++) {
                  byteArray.push(str.charCodeAt(i) & 255);
                }
                return byteArray;
              }
              function utf16leToBytes(str) {
                var c, hi, lo;
                var byteArray = [];
                for (var i = 0; i < str.length; i++) {
                  c = str.charCodeAt(i);
                  hi = c >> 8;
                  lo = c % 256;
                  byteArray.push(lo);
                  byteArray.push(hi);
                }
                return byteArray;
              }
              function base64ToBytes(str) {
                return base64.toByteArray(str);
              }
              function blitBuffer(src, dst, offset, length, unitSize) {
                if (unitSize) length -= length % unitSize;
                for (var i = 0; i < length; i++) {
                  if (i + offset >= dst.length || i >= src.length) break;
                  dst[i + offset] = src[i];
                }
                return i;
              }
              function decodeUtf8Char(str) {
                try {
                  return decodeURIComponent(str);
                } catch (err) {
                  return String.fromCharCode(65533);
                }
              }
            },
            { "base64-js": 2, ieee754: 3, "is-array": 4 },
          ],
          2: [
            function (_dereq_, module3, exports3) {
              var lookup =
                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
              (function (exports4) {
                "use strict";
                var Arr =
                  typeof Uint8Array !== "undefined" ? Uint8Array : Array;
                var PLUS = "+".charCodeAt(0);
                var SLASH = "/".charCodeAt(0);
                var NUMBER = "0".charCodeAt(0);
                var LOWER = "a".charCodeAt(0);
                var UPPER = "A".charCodeAt(0);
                function decode(elt) {
                  var code = elt.charCodeAt(0);
                  if (code === PLUS) return 62;
                  if (code === SLASH) return 63;
                  if (code < NUMBER) return -1;
                  if (code < NUMBER + 10) return code - NUMBER + 26 + 26;
                  if (code < UPPER + 26) return code - UPPER;
                  if (code < LOWER + 26) return code - LOWER + 26;
                }
                function b64ToByteArray(b64) {
                  var i, j, l, tmp, placeHolders, arr;
                  if (b64.length % 4 > 0) {
                    throw new Error(
                      "Invalid string. Length must be a multiple of 4"
                    );
                  }
                  var len = b64.length;
                  placeHolders =
                    "=" === b64.charAt(len - 2)
                      ? 2
                      : "=" === b64.charAt(len - 1)
                      ? 1
                      : 0;
                  arr = new Arr((b64.length * 3) / 4 - placeHolders);
                  l = placeHolders > 0 ? b64.length - 4 : b64.length;
                  var L = 0;
                  function push(v) {
                    arr[L++] = v;
                  }
                  for (i = 0, j = 0; i < l; i += 4, j += 3) {
                    tmp =
                      (decode(b64.charAt(i)) << 18) |
                      (decode(b64.charAt(i + 1)) << 12) |
                      (decode(b64.charAt(i + 2)) << 6) |
                      decode(b64.charAt(i + 3));
                    push((tmp & 16711680) >> 16);
                    push((tmp & 65280) >> 8);
                    push(tmp & 255);
                  }
                  if (placeHolders === 2) {
                    tmp =
                      (decode(b64.charAt(i)) << 2) |
                      (decode(b64.charAt(i + 1)) >> 4);
                    push(tmp & 255);
                  } else if (placeHolders === 1) {
                    tmp =
                      (decode(b64.charAt(i)) << 10) |
                      (decode(b64.charAt(i + 1)) << 4) |
                      (decode(b64.charAt(i + 2)) >> 2);
                    push((tmp >> 8) & 255);
                    push(tmp & 255);
                  }
                  return arr;
                }
                function uint8ToBase64(uint8) {
                  var i,
                    extraBytes = uint8.length % 3,
                    output = "",
                    temp,
                    length;
                  function encode(num) {
                    return lookup.charAt(num);
                  }
                  function tripletToBase64(num) {
                    return (
                      encode((num >> 18) & 63) +
                      encode((num >> 12) & 63) +
                      encode((num >> 6) & 63) +
                      encode(num & 63)
                    );
                  }
                  for (
                    i = 0, length = uint8.length - extraBytes;
                    i < length;
                    i += 3
                  ) {
                    temp =
                      (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
                    output += tripletToBase64(temp);
                  }
                  switch (extraBytes) {
                    case 1:
                      temp = uint8[uint8.length - 1];
                      output += encode(temp >> 2);
                      output += encode((temp << 4) & 63);
                      output += "==";
                      break;
                    case 2:
                      temp =
                        (uint8[uint8.length - 2] << 8) +
                        uint8[uint8.length - 1];
                      output += encode(temp >> 10);
                      output += encode((temp >> 4) & 63);
                      output += encode((temp << 2) & 63);
                      output += "=";
                      break;
                  }
                  return output;
                }
                exports4.toByteArray = b64ToByteArray;
                exports4.fromByteArray = uint8ToBase64;
              })(
                typeof exports3 === "undefined"
                  ? (this.base64js = {})
                  : exports3
              );
            },
            {},
          ],
          3: [
            function (_dereq_, module3, exports3) {
              exports3.read = function (buffer, offset, isLE, mLen, nBytes) {
                var e, m;
                var eLen = nBytes * 8 - mLen - 1;
                var eMax = (1 << eLen) - 1;
                var eBias = eMax >> 1;
                var nBits = -7;
                var i = isLE ? nBytes - 1 : 0;
                var d = isLE ? -1 : 1;
                var s = buffer[offset + i];
                i += d;
                e = s & ((1 << -nBits) - 1);
                s >>= -nBits;
                nBits += eLen;
                for (
                  ;
                  nBits > 0;
                  e = e * 256 + buffer[offset + i], i += d, nBits -= 8
                ) {}
                m = e & ((1 << -nBits) - 1);
                e >>= -nBits;
                nBits += mLen;
                for (
                  ;
                  nBits > 0;
                  m = m * 256 + buffer[offset + i], i += d, nBits -= 8
                ) {}
                if (e === 0) {
                  e = 1 - eBias;
                } else if (e === eMax) {
                  return m ? NaN : (s ? -1 : 1) * Infinity;
                } else {
                  m = m + Math.pow(2, mLen);
                  e = e - eBias;
                }
                return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
              };
              exports3.write = function (
                buffer,
                value,
                offset,
                isLE,
                mLen,
                nBytes
              ) {
                var e, m, c;
                var eLen = nBytes * 8 - mLen - 1;
                var eMax = (1 << eLen) - 1;
                var eBias = eMax >> 1;
                var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
                var i = isLE ? 0 : nBytes - 1;
                var d = isLE ? 1 : -1;
                var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
                value = Math.abs(value);
                if (isNaN(value) || value === Infinity) {
                  m = isNaN(value) ? 1 : 0;
                  e = eMax;
                } else {
                  e = Math.floor(Math.log(value) / Math.LN2);
                  if (value * (c = Math.pow(2, -e)) < 1) {
                    e--;
                    c *= 2;
                  }
                  if (e + eBias >= 1) {
                    value += rt / c;
                  } else {
                    value += rt * Math.pow(2, 1 - eBias);
                  }
                  if (value * c >= 2) {
                    e++;
                    c /= 2;
                  }
                  if (e + eBias >= eMax) {
                    m = 0;
                    e = eMax;
                  } else if (e + eBias >= 1) {
                    m = (value * c - 1) * Math.pow(2, mLen);
                    e = e + eBias;
                  } else {
                    m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
                    e = 0;
                  }
                }
                for (
                  ;
                  mLen >= 8;
                  buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8
                ) {}
                e = (e << mLen) | m;
                eLen += mLen;
                for (
                  ;
                  eLen > 0;
                  buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8
                ) {}
                buffer[offset + i - d] |= s * 128;
              };
            },
            {},
          ],
          4: [
            function (_dereq_, module3, exports3) {
              var isArray = Array.isArray;
              var str = Object.prototype.toString;
              module3.exports =
                isArray ||
                function (val) {
                  return !!val && "[object Array]" == str.call(val);
                };
            },
            {},
          ],
          5: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var DataReader = _dereq_("./dataReader");
              function ArrayReader(data) {
                if (data) {
                  this.data = data;
                  this.length = this.data.length;
                  this.index = 0;
                  this.zero = 0;
                  for (var i = 0; i < this.data.length; i++) {
                    data[i] = data[i] & 255;
                  }
                }
              }
              ArrayReader.prototype = new DataReader();
              ArrayReader.prototype.byteAt = function (i) {
                return this.data[this.zero + i];
              };
              ArrayReader.prototype.lastIndexOfSignature = function (sig) {
                var sig0 = sig.charCodeAt(0),
                  sig1 = sig.charCodeAt(1),
                  sig2 = sig.charCodeAt(2),
                  sig3 = sig.charCodeAt(3);
                for (var i = this.length - 4; i >= 0; --i) {
                  if (
                    this.data[i] === sig0 &&
                    this.data[i + 1] === sig1 &&
                    this.data[i + 2] === sig2 &&
                    this.data[i + 3] === sig3
                  ) {
                    return i - this.zero;
                  }
                }
                return -1;
              };
              ArrayReader.prototype.readData = function (size) {
                this.checkOffset(size);
                if (size === 0) {
                  return [];
                }
                var result = this.data.slice(
                  this.zero + this.index,
                  this.zero + this.index + size
                );
                this.index += size;
                return result;
              };
              module3.exports = ArrayReader;
            },
            { "./dataReader": 10 },
          ],
          6: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var _keyStr =
                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
              exports3.encode = function (input, utf8) {
                var output = "";
                var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
                var i = 0;
                while (i < input.length) {
                  chr1 = input.charCodeAt(i++);
                  chr2 = input.charCodeAt(i++);
                  chr3 = input.charCodeAt(i++);
                  enc1 = chr1 >> 2;
                  enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
                  enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
                  enc4 = chr3 & 63;
                  if (isNaN(chr2)) {
                    enc3 = enc4 = 64;
                  } else if (isNaN(chr3)) {
                    enc4 = 64;
                  }
                  output =
                    output +
                    _keyStr.charAt(enc1) +
                    _keyStr.charAt(enc2) +
                    _keyStr.charAt(enc3) +
                    _keyStr.charAt(enc4);
                }
                return output;
              };
              exports3.decode = function (input, utf8) {
                var output = "";
                var chr1, chr2, chr3;
                var enc1, enc2, enc3, enc4;
                var i = 0;
                input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
                while (i < input.length) {
                  enc1 = _keyStr.indexOf(input.charAt(i++));
                  enc2 = _keyStr.indexOf(input.charAt(i++));
                  enc3 = _keyStr.indexOf(input.charAt(i++));
                  enc4 = _keyStr.indexOf(input.charAt(i++));
                  chr1 = (enc1 << 2) | (enc2 >> 4);
                  chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                  chr3 = ((enc3 & 3) << 6) | enc4;
                  output = output + String.fromCharCode(chr1);
                  if (enc3 != 64) {
                    output = output + String.fromCharCode(chr2);
                  }
                  if (enc4 != 64) {
                    output = output + String.fromCharCode(chr3);
                  }
                }
                return output;
              };
            },
            {},
          ],
          7: [
            function (_dereq_, module3, exports3) {
              "use strict";
              function CompressedObject() {
                this.compressedSize = 0;
                this.uncompressedSize = 0;
                this.crc32 = 0;
                this.compressionMethod = null;
                this.compressedContent = null;
              }
              CompressedObject.prototype = {
                /**
                 * Return the decompressed content in an unspecified format.
                 * The format will depend on the decompressor.
                 * @return {Object} the decompressed content.
                 */
                getContent: function () {
                  return null;
                },
                /**
                 * Return the compressed content in an unspecified format.
                 * The format will depend on the compressed conten source.
                 * @return {Object} the compressed content.
                 */
                getCompressedContent: function () {
                  return null;
                },
              };
              module3.exports = CompressedObject;
            },
            {},
          ],
          8: [
            function (_dereq_, module3, exports3) {
              "use strict";
              exports3.STORE = {
                magic: "\0\0",
                compress: function (content, compressionOptions) {
                  return content;
                },
                uncompress: function (content) {
                  return content;
                },
                compressInputType: null,
                uncompressInputType: null,
              };
              exports3.DEFLATE = _dereq_("./flate");
            },
            { "./flate": 13 },
          ],
          9: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              var table = [
                0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615,
                3915621685, 2657392035, 249268274, 2044508324, 3772115230,
                2547177864, 162941995, 2125561021, 3887607047, 2428444049,
                498536548, 1789927666, 4089016648, 2227061214, 450548861,
                1843258603, 4107580753, 2211677639, 325883990, 1684777152,
                4251122042, 2321926636, 335633487, 1661365465, 4195302755,
                2366115317, 997073096, 1281953886, 3579855332, 2724688242,
                1006888145, 1258607687, 3524101629, 2768942443, 901097722,
                1119000684, 3686517206, 2898065728, 853044451, 1172266101,
                3705015759, 2882616665, 651767980, 1373503546, 3369554304,
                3218104598, 565507253, 1454621731, 3485111705, 3099436303,
                671266974, 1594198024, 3322730930, 2970347812, 795835527,
                1483230225, 3244367275, 3060149565, 1994146192, 31158534,
                2563907772, 4023717930, 1907459465, 112637215, 2680153253,
                3904427059, 2013776290, 251722036, 2517215374, 3775830040,
                2137656763, 141376813, 2439277719, 3865271297, 1802195444,
                476864866, 2238001368, 4066508878, 1812370925, 453092731,
                2181625025, 4111451223, 1706088902, 314042704, 2344532202,
                4240017532, 1658658271, 366619977, 2362670323, 4224994405,
                1303535960, 984961486, 2747007092, 3569037538, 1256170817,
                1037604311, 2765210733, 3554079995, 1131014506, 879679996,
                2909243462, 3663771856, 1141124467, 855842277, 2852801631,
                3708648649, 1342533948, 654459306, 3188396048, 3373015174,
                1466479909, 544179635, 3110523913, 3462522015, 1591671054,
                702138776, 2966460450, 3352799412, 1504918807, 783551873,
                3082640443, 3233442989, 3988292384, 2596254646, 62317068,
                1957810842, 3939845945, 2647816111, 81470997, 1943803523,
                3814918930, 2489596804, 225274430, 2053790376, 3826175755,
                2466906013, 167816743, 2097651377, 4027552580, 2265490386,
                503444072, 1762050814, 4150417245, 2154129355, 426522225,
                1852507879, 4275313526, 2312317920, 282753626, 1742555852,
                4189708143, 2394877945, 397917763, 1622183637, 3604390888,
                2714866558, 953729732, 1340076626, 3518719985, 2797360999,
                1068828381, 1219638859, 3624741850, 2936675148, 906185462,
                1090812512, 3747672003, 2825379669, 829329135, 1181335161,
                3412177804, 3160834842, 628085408, 1382605366, 3423369109,
                3138078467, 570562233, 1426400815, 3317316542, 2998733608,
                733239954, 1555261956, 3268935591, 3050360625, 752459403,
                1541320221, 2607071920, 3965973030, 1969922972, 40735498,
                2617837225, 3943577151, 1913087877, 83908371, 2512341634,
                3803740692, 2075208622, 213261112, 2463272603, 3855990285,
                2094854071, 198958881, 2262029012, 4057260610, 1759359992,
                534414190, 2176718541, 4139329115, 1873836001, 414664567,
                2282248934, 4279200368, 1711684554, 285281116, 2405801727,
                4167216745, 1634467795, 376229701, 2685067896, 3608007406,
                1308918612, 956543938, 2808555105, 3495958263, 1231636301,
                1047427035, 2932959818, 3654703836, 1088359270, 936918e3,
                2847714899, 3736837829, 1202900863, 817233897, 3183342108,
                3401237130, 1404277552, 615818150, 3134207493, 3453421203,
                1423857449, 601450431, 3009837614, 3294710456, 1567103746,
                711928724, 3020668471, 3272380065, 1510334235, 755167117,
              ];
              module3.exports = function crc32(input, crc) {
                if (typeof input === "undefined" || !input.length) {
                  return 0;
                }
                var isArray = utils.getTypeOf(input) !== "string";
                if (typeof crc == "undefined") {
                  crc = 0;
                }
                var x = 0;
                var y = 0;
                var b = 0;
                crc = crc ^ -1;
                for (var i = 0, iTop = input.length; i < iTop; i++) {
                  b = isArray ? input[i] : input.charCodeAt(i);
                  y = (crc ^ b) & 255;
                  x = table[y];
                  crc = (crc >>> 8) ^ x;
                }
                return crc ^ -1;
              };
            },
            { "./utils": 26 },
          ],
          10: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              function DataReader(data) {
                this.data = null;
                this.length = 0;
                this.index = 0;
                this.zero = 0;
              }
              DataReader.prototype = {
                /**
                 * Check that the offset will not go too far.
                 * @param {string} offset the additional offset to check.
                 * @throws {Error} an Error if the offset is out of bounds.
                 */
                checkOffset: function (offset) {
                  this.checkIndex(this.index + offset);
                },
                /**
                 * Check that the specifed index will not be too far.
                 * @param {string} newIndex the index to check.
                 * @throws {Error} an Error if the index is out of bounds.
                 */
                checkIndex: function (newIndex) {
                  if (this.length < this.zero + newIndex || newIndex < 0) {
                    throw new Error(
                      "End of data reached (data length = " +
                        this.length +
                        ", asked index = " +
                        newIndex +
                        "). Corrupted zip ?"
                    );
                  }
                },
                /**
                 * Change the index.
                 * @param {number} newIndex The new index.
                 * @throws {Error} if the new index is out of the data.
                 */
                setIndex: function (newIndex) {
                  this.checkIndex(newIndex);
                  this.index = newIndex;
                },
                /**
                 * Skip the next n bytes.
                 * @param {number} n the number of bytes to skip.
                 * @throws {Error} if the new index is out of the data.
                 */
                skip: function (n) {
                  this.setIndex(this.index + n);
                },
                /**
                 * Get the byte at the specified index.
                 * @param {number} i the index to use.
                 * @return {number} a byte.
                 */
                byteAt: function (i) {},
                /**
                 * Get the next number with a given byte size.
                 * @param {number} size the number of bytes to read.
                 * @return {number} the corresponding number.
                 */
                readInt: function (size) {
                  var result = 0,
                    i;
                  this.checkOffset(size);
                  for (i = this.index + size - 1; i >= this.index; i--) {
                    result = (result << 8) + this.byteAt(i);
                  }
                  this.index += size;
                  return result;
                },
                /**
                 * Get the next string with a given byte size.
                 * @param {number} size the number of bytes to read.
                 * @return {string} the corresponding string.
                 */
                readString: function (size) {
                  return utils.transformTo("string", this.readData(size));
                },
                /**
                 * Get raw data without conversion, <size> bytes.
                 * @param {number} size the number of bytes to read.
                 * @return {Object} the raw data, implementation specific.
                 */
                readData: function (size) {},
                /**
                 * Find the last occurence of a zip signature (4 bytes).
                 * @param {string} sig the signature to find.
                 * @return {number} the index of the last occurence, -1 if not found.
                 */
                lastIndexOfSignature: function (sig) {},
                /**
                 * Get the next date.
                 * @return {Date} the date.
                 */
                readDate: function () {
                  var dostime = this.readInt(4);
                  return new Date(
                    ((dostime >> 25) & 127) + 1980,
                    // year
                    ((dostime >> 21) & 15) - 1,
                    // month
                    (dostime >> 16) & 31,
                    // day
                    (dostime >> 11) & 31,
                    // hour
                    (dostime >> 5) & 63,
                    // minute
                    (dostime & 31) << 1
                  );
                },
              };
              module3.exports = DataReader;
            },
            { "./utils": 26 },
          ],
          11: [
            function (_dereq_, module3, exports3) {
              "use strict";
              exports3.base64 = false;
              exports3.binary = false;
              exports3.dir = false;
              exports3.createFolders = false;
              exports3.date = null;
              exports3.compression = null;
              exports3.compressionOptions = null;
              exports3.comment = null;
              exports3.unixPermissions = null;
              exports3.dosPermissions = null;
            },
            {},
          ],
          12: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              exports3.string2binary = function (str) {
                return utils.string2binary(str);
              };
              exports3.string2Uint8Array = function (str) {
                return utils.transformTo("uint8array", str);
              };
              exports3.uint8Array2String = function (array) {
                return utils.transformTo("string", array);
              };
              exports3.string2Blob = function (str) {
                var buffer = utils.transformTo("arraybuffer", str);
                return utils.arrayBuffer2Blob(buffer);
              };
              exports3.arrayBuffer2Blob = function (buffer) {
                return utils.arrayBuffer2Blob(buffer);
              };
              exports3.transformTo = function (outputType, input) {
                return utils.transformTo(outputType, input);
              };
              exports3.getTypeOf = function (input) {
                return utils.getTypeOf(input);
              };
              exports3.checkSupport = function (type) {
                return utils.checkSupport(type);
              };
              exports3.MAX_VALUE_16BITS = utils.MAX_VALUE_16BITS;
              exports3.MAX_VALUE_32BITS = utils.MAX_VALUE_32BITS;
              exports3.pretty = function (str) {
                return utils.pretty(str);
              };
              exports3.findCompression = function (compressionMethod) {
                return utils.findCompression(compressionMethod);
              };
              exports3.isRegExp = function (object) {
                return utils.isRegExp(object);
              };
            },
            { "./utils": 26 },
          ],
          13: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var USE_TYPEDARRAY =
                typeof Uint8Array !== "undefined" &&
                typeof Uint16Array !== "undefined" &&
                typeof Uint32Array !== "undefined";
              var pako = _dereq_("pako");
              exports3.uncompressInputType = USE_TYPEDARRAY
                ? "uint8array"
                : "array";
              exports3.compressInputType = USE_TYPEDARRAY
                ? "uint8array"
                : "array";
              exports3.magic = "\b\0";
              exports3.compress = function (input, compressionOptions) {
                return pako.deflateRaw(input, {
                  level: compressionOptions.level || -1,
                  // default compression
                });
              };
              exports3.uncompress = function (input) {
                return pako.inflateRaw(input);
              };
            },
            { pako: 29 },
          ],
          14: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var base64 = _dereq_("./base64");
              function JSZip(data, options) {
                if (!(this instanceof JSZip)) return new JSZip(data, options);
                this.files = {};
                this.comment = null;
                this.root = "";
                if (data) {
                  this.load(data, options);
                }
                this.clone = function () {
                  var newObj = new JSZip();
                  for (var i in this) {
                    if (typeof this[i] !== "function") {
                      newObj[i] = this[i];
                    }
                  }
                  return newObj;
                };
              }
              JSZip.prototype = _dereq_("./object");
              JSZip.prototype.load = _dereq_("./load");
              JSZip.support = _dereq_("./support");
              JSZip.defaults = _dereq_("./defaults");
              JSZip.utils = _dereq_("./deprecatedPublicUtils");
              JSZip.base64 = {
                /**
                 * @deprecated
                 * This method will be removed in a future version without replacement.
                 */
                encode: function (input) {
                  return base64.encode(input);
                },
                /**
                 * @deprecated
                 * This method will be removed in a future version without replacement.
                 */
                decode: function (input) {
                  return base64.decode(input);
                },
              };
              JSZip.compressions = _dereq_("./compressions");
              module3.exports = JSZip;
            },
            {
              "./base64": 6,
              "./compressions": 8,
              "./defaults": 11,
              "./deprecatedPublicUtils": 12,
              "./load": 15,
              "./object": 18,
              "./support": 22,
            },
          ],
          15: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var base64 = _dereq_("./base64");
              var utf8 = _dereq_("./utf8");
              var utils = _dereq_("./utils");
              var ZipEntries = _dereq_("./zipEntries");
              module3.exports = function (data, options) {
                var files, zipEntries, i, input;
                options = utils.extend(options || {}, {
                  base64: false,
                  checkCRC32: false,
                  optimizedBinaryString: false,
                  createFolders: false,
                  decodeFileName: utf8.utf8decode,
                });
                if (options.base64) {
                  data = base64.decode(data);
                }
                zipEntries = new ZipEntries(data, options);
                files = zipEntries.files;
                for (i = 0; i < files.length; i++) {
                  input = files[i];
                  this.file(input.fileNameStr, input.decompressed, {
                    binary: true,
                    optimizedBinaryString: true,
                    date: input.date,
                    dir: input.dir,
                    comment: input.fileCommentStr.length
                      ? input.fileCommentStr
                      : null,
                    unixPermissions: input.unixPermissions,
                    dosPermissions: input.dosPermissions,
                    createFolders: options.createFolders,
                  });
                }
                if (zipEntries.zipComment.length) {
                  this.comment = zipEntries.zipComment;
                }
                return this;
              };
            },
            { "./base64": 6, "./utf8": 25, "./utils": 26, "./zipEntries": 27 },
          ],
          16: [
            function (_dereq_, module3, exports3) {
              (function (Buffer) {
                "use strict";
                module3.exports = function (data, encoding) {
                  return new Buffer(data, encoding);
                };
                module3.exports.test = function (b) {
                  return Buffer.isBuffer(b);
                };
              }).call(this, _dereq_("buffer").Buffer);
            },
            { buffer: 1 },
          ],
          17: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var Uint8ArrayReader = _dereq_("./uint8ArrayReader");
              function NodeBufferReader(data) {
                this.data = data;
                this.length = this.data.length;
                this.index = 0;
                this.zero = 0;
              }
              NodeBufferReader.prototype = new Uint8ArrayReader();
              NodeBufferReader.prototype.readData = function (size) {
                this.checkOffset(size);
                var result = this.data.slice(
                  this.zero + this.index,
                  this.zero + this.index + size
                );
                this.index += size;
                return result;
              };
              module3.exports = NodeBufferReader;
            },
            { "./uint8ArrayReader": 23 },
          ],
          18: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var support = _dereq_("./support");
              var utils = _dereq_("./utils");
              var crc32 = _dereq_("./crc32");
              var signature = _dereq_("./signature");
              var defaults = _dereq_("./defaults");
              var base64 = _dereq_("./base64");
              var compressions = _dereq_("./compressions");
              var CompressedObject = _dereq_("./compressedObject");
              var nodeBuffer = _dereq_("./nodeBuffer");
              var utf8 = _dereq_("./utf8");
              var StringWriter = _dereq_("./stringWriter");
              var Uint8ArrayWriter = _dereq_("./uint8ArrayWriter");
              var getRawData = function (file) {
                if (file._data instanceof CompressedObject) {
                  file._data = file._data.getContent();
                  file.options.binary = true;
                  file.options.base64 = false;
                  if (utils.getTypeOf(file._data) === "uint8array") {
                    var copy = file._data;
                    file._data = new Uint8Array(copy.length);
                    if (copy.length !== 0) {
                      file._data.set(copy, 0);
                    }
                  }
                }
                return file._data;
              };
              var getBinaryData = function (file) {
                var result = getRawData(file),
                  type = utils.getTypeOf(result);
                if (type === "string") {
                  if (!file.options.binary) {
                    if (support.nodebuffer) {
                      return nodeBuffer(result, "utf-8");
                    }
                  }
                  return file.asBinary();
                }
                return result;
              };
              var dataToString = function (asUTF8) {
                var result = getRawData(this);
                if (result === null || typeof result === "undefined") {
                  return "";
                }
                if (this.options.base64) {
                  result = base64.decode(result);
                }
                if (asUTF8 && this.options.binary) {
                  result = out.utf8decode(result);
                } else {
                  result = utils.transformTo("string", result);
                }
                if (!asUTF8 && !this.options.binary) {
                  result = utils.transformTo("string", out.utf8encode(result));
                }
                return result;
              };
              var ZipObject = function (name, data, options) {
                this.name = name;
                this.dir = options.dir;
                this.date = options.date;
                this.comment = options.comment;
                this.unixPermissions = options.unixPermissions;
                this.dosPermissions = options.dosPermissions;
                this._data = data;
                this.options = options;
                this._initialMetadata = {
                  dir: options.dir,
                  date: options.date,
                };
              };
              ZipObject.prototype = {
                /**
                 * Return the content as UTF8 string.
                 * @return {string} the UTF8 string.
                 */
                asText: function () {
                  return dataToString.call(this, true);
                },
                /**
                 * Returns the binary content.
                 * @return {string} the content as binary.
                 */
                asBinary: function () {
                  return dataToString.call(this, false);
                },
                /**
                 * Returns the content as a nodejs Buffer.
                 * @return {Buffer} the content as a Buffer.
                 */
                asNodeBuffer: function () {
                  var result = getBinaryData(this);
                  return utils.transformTo("nodebuffer", result);
                },
                /**
                 * Returns the content as an Uint8Array.
                 * @return {Uint8Array} the content as an Uint8Array.
                 */
                asUint8Array: function () {
                  var result = getBinaryData(this);
                  return utils.transformTo("uint8array", result);
                },
                /**
                 * Returns the content as an ArrayBuffer.
                 * @return {ArrayBuffer} the content as an ArrayBufer.
                 */
                asArrayBuffer: function () {
                  return this.asUint8Array().buffer;
                },
              };
              var decToHex = function (dec, bytes) {
                var hex = "",
                  i;
                for (i = 0; i < bytes; i++) {
                  hex += String.fromCharCode(dec & 255);
                  dec = dec >>> 8;
                }
                return hex;
              };
              var prepareFileAttrs = function (o) {
                o = o || {};
                if (
                  o.base64 === true &&
                  (o.binary === null || o.binary === void 0)
                ) {
                  o.binary = true;
                }
                o = utils.extend(o, defaults);
                o.date = o.date || /* @__PURE__ */ new Date();
                if (o.compression !== null)
                  o.compression = o.compression.toUpperCase();
                return o;
              };
              var fileAdd = function (name, data, o) {
                var dataType = utils.getTypeOf(data),
                  parent;
                o = prepareFileAttrs(o);
                if (typeof o.unixPermissions === "string") {
                  o.unixPermissions = parseInt(o.unixPermissions, 8);
                }
                if (o.unixPermissions && o.unixPermissions & 16384) {
                  o.dir = true;
                }
                if (o.dosPermissions && o.dosPermissions & 16) {
                  o.dir = true;
                }
                if (o.dir) {
                  name = forceTrailingSlash(name);
                }
                if (o.createFolders && (parent = parentFolder(name))) {
                  folderAdd.call(this, parent, true);
                }
                if (o.dir || data === null || typeof data === "undefined") {
                  o.base64 = false;
                  o.binary = false;
                  data = null;
                  dataType = null;
                } else if (dataType === "string") {
                  if (o.binary && !o.base64) {
                    if (o.optimizedBinaryString !== true) {
                      data = utils.string2binary(data);
                    }
                  }
                } else {
                  o.base64 = false;
                  o.binary = true;
                  if (!dataType && !(data instanceof CompressedObject)) {
                    throw new Error(
                      "The data of '" + name + "' is in an unsupported format !"
                    );
                  }
                  if (dataType === "arraybuffer") {
                    data = utils.transformTo("uint8array", data);
                  }
                }
                var object = new ZipObject(name, data, o);
                this.files[name] = object;
                return object;
              };
              var parentFolder = function (path) {
                if (path.slice(-1) == "/") {
                  path = path.substring(0, path.length - 1);
                }
                var lastSlash = path.lastIndexOf("/");
                return lastSlash > 0 ? path.substring(0, lastSlash) : "";
              };
              var forceTrailingSlash = function (path) {
                if (path.slice(-1) != "/") {
                  path += "/";
                }
                return path;
              };
              var folderAdd = function (name, createFolders) {
                createFolders =
                  typeof createFolders !== "undefined" ? createFolders : false;
                name = forceTrailingSlash(name);
                if (!this.files[name]) {
                  fileAdd.call(this, name, null, {
                    dir: true,
                    createFolders,
                  });
                }
                return this.files[name];
              };
              var generateCompressedObjectFrom = function (
                file,
                compression,
                compressionOptions
              ) {
                var result = new CompressedObject(),
                  content;
                if (file._data instanceof CompressedObject) {
                  result.uncompressedSize = file._data.uncompressedSize;
                  result.crc32 = file._data.crc32;
                  if (result.uncompressedSize === 0 || file.dir) {
                    compression = compressions["STORE"];
                    result.compressedContent = "";
                    result.crc32 = 0;
                  } else if (
                    file._data.compressionMethod === compression.magic
                  ) {
                    result.compressedContent =
                      file._data.getCompressedContent();
                  } else {
                    content = file._data.getContent();
                    result.compressedContent = compression.compress(
                      utils.transformTo(compression.compressInputType, content),
                      compressionOptions
                    );
                  }
                } else {
                  content = getBinaryData(file);
                  if (!content || content.length === 0 || file.dir) {
                    compression = compressions["STORE"];
                    content = "";
                  }
                  result.uncompressedSize = content.length;
                  result.crc32 = crc32(content);
                  result.compressedContent = compression.compress(
                    utils.transformTo(compression.compressInputType, content),
                    compressionOptions
                  );
                }
                result.compressedSize = result.compressedContent.length;
                result.compressionMethod = compression.magic;
                return result;
              };
              var generateUnixExternalFileAttr = function (
                unixPermissions,
                isDir
              ) {
                var result = unixPermissions;
                if (!unixPermissions) {
                  result = isDir ? 16893 : 33204;
                }
                return (result & 65535) << 16;
              };
              var generateDosExternalFileAttr = function (
                dosPermissions,
                isDir
              ) {
                return (dosPermissions || 0) & 63;
              };
              var generateZipParts = function (
                name,
                file,
                compressedObject,
                offset,
                platform,
                encodeFileName
              ) {
                var data = compressedObject.compressedContent,
                  useCustomEncoding = encodeFileName !== utf8.utf8encode,
                  encodedFileName = utils.transformTo(
                    "string",
                    encodeFileName(file.name)
                  ),
                  utfEncodedFileName = utils.transformTo(
                    "string",
                    utf8.utf8encode(file.name)
                  ),
                  comment = file.comment || "",
                  encodedComment = utils.transformTo(
                    "string",
                    encodeFileName(comment)
                  ),
                  utfEncodedComment = utils.transformTo(
                    "string",
                    utf8.utf8encode(comment)
                  ),
                  useUTF8ForFileName =
                    utfEncodedFileName.length !== file.name.length,
                  useUTF8ForComment =
                    utfEncodedComment.length !== comment.length,
                  o = file.options,
                  dosTime,
                  dosDate,
                  extraFields = "",
                  unicodePathExtraField = "",
                  unicodeCommentExtraField = "",
                  dir,
                  date;
                if (file._initialMetadata.dir !== file.dir) {
                  dir = file.dir;
                } else {
                  dir = o.dir;
                }
                if (file._initialMetadata.date !== file.date) {
                  date = file.date;
                } else {
                  date = o.date;
                }
                var extFileAttr = 0;
                var versionMadeBy = 0;
                if (dir) {
                  extFileAttr |= 16;
                }
                if (platform === "UNIX") {
                  versionMadeBy = 798;
                  extFileAttr |= generateUnixExternalFileAttr(
                    file.unixPermissions,
                    dir
                  );
                } else {
                  versionMadeBy = 20;
                  extFileAttr |= generateDosExternalFileAttr(
                    file.dosPermissions,
                    dir
                  );
                }
                dosTime = date.getHours();
                dosTime = dosTime << 6;
                dosTime = dosTime | date.getMinutes();
                dosTime = dosTime << 5;
                dosTime = dosTime | (date.getSeconds() / 2);
                dosDate = date.getFullYear() - 1980;
                dosDate = dosDate << 4;
                dosDate = dosDate | (date.getMonth() + 1);
                dosDate = dosDate << 5;
                dosDate = dosDate | date.getDate();
                if (useUTF8ForFileName) {
                  unicodePathExtraField = // Version
                    decToHex(1, 1) + // NameCRC32
                    decToHex(crc32(encodedFileName), 4) + // UnicodeName
                    utfEncodedFileName;
                  extraFields += // Info-ZIP Unicode Path Extra Field
                    "up" + // size
                    decToHex(unicodePathExtraField.length, 2) + // content
                    unicodePathExtraField;
                }
                if (useUTF8ForComment) {
                  unicodeCommentExtraField = // Version
                    decToHex(1, 1) + // CommentCRC32
                    decToHex(this.crc32(encodedComment), 4) + // UnicodeName
                    utfEncodedComment;
                  extraFields += // Info-ZIP Unicode Path Extra Field
                    "uc" + // size
                    decToHex(unicodeCommentExtraField.length, 2) + // content
                    unicodeCommentExtraField;
                }
                var header = "";
                header += "\n\0";
                header +=
                  !useCustomEncoding &&
                  (useUTF8ForFileName || useUTF8ForComment)
                    ? "\0\b"
                    : "\0\0";
                header += compressedObject.compressionMethod;
                header += decToHex(dosTime, 2);
                header += decToHex(dosDate, 2);
                header += decToHex(compressedObject.crc32, 4);
                header += decToHex(compressedObject.compressedSize, 4);
                header += decToHex(compressedObject.uncompressedSize, 4);
                header += decToHex(encodedFileName.length, 2);
                header += decToHex(extraFields.length, 2);
                var fileRecord =
                  signature.LOCAL_FILE_HEADER +
                  header +
                  encodedFileName +
                  extraFields;
                var dirRecord =
                  signature.CENTRAL_FILE_HEADER + // version made by (00: DOS)
                  decToHex(versionMadeBy, 2) + // file header (common to file and central directory)
                  header + // file comment length
                  decToHex(encodedComment.length, 2) + // disk number start
                  "\0\0\0\0" + // external file attributes
                  decToHex(extFileAttr, 4) + // relative offset of local header
                  decToHex(offset, 4) + // file name
                  encodedFileName + // extra field
                  extraFields + // file comment
                  encodedComment;
                return {
                  fileRecord,
                  dirRecord,
                  compressedObject,
                };
              };
              var out = {
                /**
                 * Read an existing zip and merge the data in the current JSZip object.
                 * The implementation is in jszip-load.js, don't forget to include it.
                 * @param {String|ArrayBuffer|Uint8Array|Buffer} stream  The stream to load
                 * @param {Object} options Options for loading the stream.
                 *  options.base64 : is the stream in base64 ? default : false
                 * @return {JSZip} the current JSZip object
                 */
                load: function (stream, options) {
                  throw new Error(
                    "Load method is not defined. Is the file jszip-load.js included ?"
                  );
                },
                /**
                 * Filter nested files/folders with the specified function.
                 * @param {Function} search the predicate to use :
                 * function (relativePath, file) {...}
                 * It takes 2 arguments : the relative path and the file.
                 * @return {Array} An array of matching elements.
                 */
                filter: function (search) {
                  var result = [],
                    filename,
                    relativePath,
                    file,
                    fileClone;
                  for (filename in this.files) {
                    if (!this.files.hasOwnProperty(filename)) {
                      continue;
                    }
                    file = this.files[filename];
                    fileClone = new ZipObject(
                      file.name,
                      file._data,
                      utils.extend(file.options)
                    );
                    relativePath = filename.slice(
                      this.root.length,
                      filename.length
                    );
                    if (
                      filename.slice(0, this.root.length) === this.root && // the file is in the current root
                      search(relativePath, fileClone)
                    ) {
                      result.push(fileClone);
                    }
                  }
                  return result;
                },
                /**
                 * Add a file to the zip file, or search a file.
                 * @param   {string|RegExp} name The name of the file to add (if data is defined),
                 * the name of the file to find (if no data) or a regex to match files.
                 * @param   {String|ArrayBuffer|Uint8Array|Buffer} data  The file data, either raw or base64 encoded
                 * @param   {Object} o     File options
                 * @return  {JSZip|Object|Array} this JSZip object (when adding a file),
                 * a file (when searching by string) or an array of files (when searching by regex).
                 */
                file: function (name, data, o) {
                  if (arguments.length === 1) {
                    if (utils.isRegExp(name)) {
                      var regexp = name;
                      return this.filter(function (relativePath, file) {
                        return !file.dir && regexp.test(relativePath);
                      });
                    } else {
                      return (
                        this.filter(function (relativePath, file) {
                          return !file.dir && relativePath === name;
                        })[0] || null
                      );
                    }
                  } else {
                    name = this.root + name;
                    fileAdd.call(this, name, data, o);
                  }
                  return this;
                },
                /**
                 * Add a directory to the zip file, or search.
                 * @param   {String|RegExp} arg The name of the directory to add, or a regex to search folders.
                 * @return  {JSZip} an object with the new directory as the root, or an array containing matching folders.
                 */
                folder: function (arg) {
                  if (!arg) {
                    return this;
                  }
                  if (utils.isRegExp(arg)) {
                    return this.filter(function (relativePath, file) {
                      return file.dir && arg.test(relativePath);
                    });
                  }
                  var name = this.root + arg;
                  var newFolder = folderAdd.call(this, name);
                  var ret = this.clone();
                  ret.root = newFolder.name;
                  return ret;
                },
                /**
                 * Delete a file, or a directory and all sub-files, from the zip
                 * @param {string} name the name of the file to delete
                 * @return {JSZip} this JSZip object
                 */
                remove: function (name) {
                  name = this.root + name;
                  var file = this.files[name];
                  if (!file) {
                    if (name.slice(-1) != "/") {
                      name += "/";
                    }
                    file = this.files[name];
                  }
                  if (file && !file.dir) {
                    delete this.files[name];
                  } else {
                    var kids = this.filter(function (relativePath, file2) {
                      return file2.name.slice(0, name.length) === name;
                    });
                    for (var i = 0; i < kids.length; i++) {
                      delete this.files[kids[i].name];
                    }
                  }
                  return this;
                },
                /**
                 * Generate the complete zip file
                 * @param {Object} options the options to generate the zip file :
                 * - base64, (deprecated, use type instead) true to generate base64.
                 * - compression, "STORE" by default.
                 * - type, "base64" by default. Values are : string, base64, uint8array, arraybuffer, blob.
                 * @return {String|Uint8Array|ArrayBuffer|Buffer|Blob} the zip file
                 */
                generate: function (options) {
                  options = utils.extend(options || {}, {
                    base64: true,
                    compression: "STORE",
                    compressionOptions: null,
                    type: "base64",
                    platform: "DOS",
                    comment: null,
                    mimeType: "application/zip",
                    encodeFileName: utf8.utf8encode,
                  });
                  utils.checkSupport(options.type);
                  if (
                    options.platform === "darwin" ||
                    options.platform === "freebsd" ||
                    options.platform === "linux" ||
                    options.platform === "sunos"
                  ) {
                    options.platform = "UNIX";
                  }
                  if (options.platform === "win32") {
                    options.platform = "DOS";
                  }
                  var zipData = [],
                    localDirLength = 0,
                    centralDirLength = 0,
                    writer,
                    i,
                    encodedComment = utils.transformTo(
                      "string",
                      options.encodeFileName(
                        options.comment || this.comment || ""
                      )
                    );
                  for (var name in this.files) {
                    if (!this.files.hasOwnProperty(name)) {
                      continue;
                    }
                    var file = this.files[name];
                    var compressionName =
                      file.options.compression ||
                      options.compression.toUpperCase();
                    var compression = compressions[compressionName];
                    if (!compression) {
                      throw new Error(
                        compressionName + " is not a valid compression method !"
                      );
                    }
                    var compressionOptions =
                      file.options.compressionOptions ||
                      options.compressionOptions ||
                      {};
                    var compressedObject = generateCompressedObjectFrom.call(
                      this,
                      file,
                      compression,
                      compressionOptions
                    );
                    var zipPart = generateZipParts.call(
                      this,
                      name,
                      file,
                      compressedObject,
                      localDirLength,
                      options.platform,
                      options.encodeFileName
                    );
                    localDirLength +=
                      zipPart.fileRecord.length +
                      compressedObject.compressedSize;
                    centralDirLength += zipPart.dirRecord.length;
                    zipData.push(zipPart);
                  }
                  var dirEnd = "";
                  dirEnd =
                    signature.CENTRAL_DIRECTORY_END + // number of this disk
                    "\0\0\0\0" + // total number of entries in the central directory on this disk
                    decToHex(zipData.length, 2) + // total number of entries in the central directory
                    decToHex(zipData.length, 2) + // size of the central directory   4 bytes
                    decToHex(centralDirLength, 4) + // offset of start of central directory with respect to the starting disk number
                    decToHex(localDirLength, 4) + // .ZIP file comment length
                    decToHex(encodedComment.length, 2) + // .ZIP file comment
                    encodedComment;
                  var typeName = options.type.toLowerCase();
                  if (
                    typeName === "uint8array" ||
                    typeName === "arraybuffer" ||
                    typeName === "blob" ||
                    typeName === "nodebuffer"
                  ) {
                    writer = new Uint8ArrayWriter(
                      localDirLength + centralDirLength + dirEnd.length
                    );
                  } else {
                    writer = new StringWriter(
                      localDirLength + centralDirLength + dirEnd.length
                    );
                  }
                  for (i = 0; i < zipData.length; i++) {
                    writer.append(zipData[i].fileRecord);
                    writer.append(
                      zipData[i].compressedObject.compressedContent
                    );
                  }
                  for (i = 0; i < zipData.length; i++) {
                    writer.append(zipData[i].dirRecord);
                  }
                  writer.append(dirEnd);
                  var zip = writer.finalize();
                  switch (options.type.toLowerCase()) {
                    case "uint8array":
                    case "arraybuffer":
                    case "nodebuffer":
                      return utils.transformTo(options.type.toLowerCase(), zip);
                    case "blob":
                      return utils.arrayBuffer2Blob(
                        utils.transformTo("arraybuffer", zip),
                        options.mimeType
                      );
                    case "base64":
                      return options.base64 ? base64.encode(zip) : zip;
                    default:
                      return zip;
                  }
                },
                /**
                 * @deprecated
                 * This method will be removed in a future version without replacement.
                 */
                crc32: function (input, crc) {
                  return crc32(input, crc);
                },
                /**
                 * @deprecated
                 * This method will be removed in a future version without replacement.
                 */
                utf8encode: function (string) {
                  return utils.transformTo("string", utf8.utf8encode(string));
                },
                /**
                 * @deprecated
                 * This method will be removed in a future version without replacement.
                 */
                utf8decode: function (input) {
                  return utf8.utf8decode(input);
                },
              };
              module3.exports = out;
            },
            {
              "./base64": 6,
              "./compressedObject": 7,
              "./compressions": 8,
              "./crc32": 9,
              "./defaults": 11,
              "./nodeBuffer": 16,
              "./signature": 19,
              "./stringWriter": 21,
              "./support": 22,
              "./uint8ArrayWriter": 24,
              "./utf8": 25,
              "./utils": 26,
            },
          ],
          19: [
            function (_dereq_, module3, exports3) {
              "use strict";
              exports3.LOCAL_FILE_HEADER = "PK";
              exports3.CENTRAL_FILE_HEADER = "PK";
              exports3.CENTRAL_DIRECTORY_END = "PK";
              exports3.ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\x07";
              exports3.ZIP64_CENTRAL_DIRECTORY_END = "PK";
              exports3.DATA_DESCRIPTOR = "PK\x07\b";
            },
            {},
          ],
          20: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var DataReader = _dereq_("./dataReader");
              var utils = _dereq_("./utils");
              function StringReader(data, optimizedBinaryString) {
                this.data = data;
                if (!optimizedBinaryString) {
                  this.data = utils.string2binary(this.data);
                }
                this.length = this.data.length;
                this.index = 0;
                this.zero = 0;
              }
              StringReader.prototype = new DataReader();
              StringReader.prototype.byteAt = function (i) {
                return this.data.charCodeAt(this.zero + i);
              };
              StringReader.prototype.lastIndexOfSignature = function (sig) {
                return this.data.lastIndexOf(sig) - this.zero;
              };
              StringReader.prototype.readData = function (size) {
                this.checkOffset(size);
                var result = this.data.slice(
                  this.zero + this.index,
                  this.zero + this.index + size
                );
                this.index += size;
                return result;
              };
              module3.exports = StringReader;
            },
            { "./dataReader": 10, "./utils": 26 },
          ],
          21: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              var StringWriter = function () {
                this.data = [];
              };
              StringWriter.prototype = {
                /**
                 * Append any content to the current string.
                 * @param {Object} input the content to add.
                 */
                append: function (input) {
                  input = utils.transformTo("string", input);
                  this.data.push(input);
                },
                /**
                 * Finalize the construction an return the result.
                 * @return {string} the generated string.
                 */
                finalize: function () {
                  return this.data.join("");
                },
              };
              module3.exports = StringWriter;
            },
            { "./utils": 26 },
          ],
          22: [
            function (_dereq_, module3, exports3) {
              (function (Buffer) {
                "use strict";
                exports3.base64 = true;
                exports3.array = true;
                exports3.string = true;
                exports3.arraybuffer =
                  typeof ArrayBuffer !== "undefined" &&
                  typeof Uint8Array !== "undefined";
                exports3.nodebuffer = typeof Buffer !== "undefined";
                exports3.uint8array = typeof Uint8Array !== "undefined";
                if (typeof ArrayBuffer === "undefined") {
                  exports3.blob = false;
                } else {
                  var buffer = new ArrayBuffer(0);
                  try {
                    exports3.blob =
                      new Blob([buffer], {
                        type: "application/zip",
                      }).size === 0;
                  } catch (e) {
                    try {
                      var Builder =
                        window.BlobBuilder ||
                        window.WebKitBlobBuilder ||
                        window.MozBlobBuilder ||
                        window.MSBlobBuilder;
                      var builder = new Builder();
                      builder.append(buffer);
                      exports3.blob =
                        builder.getBlob("application/zip").size === 0;
                    } catch (e2) {
                      exports3.blob = false;
                    }
                  }
                }
              }).call(this, _dereq_("buffer").Buffer);
            },
            { buffer: 1 },
          ],
          23: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var ArrayReader = _dereq_("./arrayReader");
              function Uint8ArrayReader(data) {
                if (data) {
                  this.data = data;
                  this.length = this.data.length;
                  this.index = 0;
                  this.zero = 0;
                }
              }
              Uint8ArrayReader.prototype = new ArrayReader();
              Uint8ArrayReader.prototype.readData = function (size) {
                this.checkOffset(size);
                if (size === 0) {
                  return new Uint8Array(0);
                }
                var result = this.data.subarray(
                  this.zero + this.index,
                  this.zero + this.index + size
                );
                this.index += size;
                return result;
              };
              module3.exports = Uint8ArrayReader;
            },
            { "./arrayReader": 5 },
          ],
          24: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              var Uint8ArrayWriter = function (length) {
                this.data = new Uint8Array(length);
                this.index = 0;
              };
              Uint8ArrayWriter.prototype = {
                /**
                 * Append any content to the current array.
                 * @param {Object} input the content to add.
                 */
                append: function (input) {
                  if (input.length !== 0) {
                    input = utils.transformTo("uint8array", input);
                    this.data.set(input, this.index);
                    this.index += input.length;
                  }
                },
                /**
                 * Finalize the construction an return the result.
                 * @return {Uint8Array} the generated array.
                 */
                finalize: function () {
                  return this.data;
                },
              };
              module3.exports = Uint8ArrayWriter;
            },
            { "./utils": 26 },
          ],
          25: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./utils");
              var support = _dereq_("./support");
              var nodeBuffer = _dereq_("./nodeBuffer");
              var _utf8len = new Array(256);
              for (var i = 0; i < 256; i++) {
                _utf8len[i] =
                  i >= 252
                    ? 6
                    : i >= 248
                    ? 5
                    : i >= 240
                    ? 4
                    : i >= 224
                    ? 3
                    : i >= 192
                    ? 2
                    : 1;
              }
              _utf8len[254] = _utf8len[254] = 1;
              var string2buf = function (str) {
                var buf,
                  c,
                  c2,
                  m_pos,
                  i2,
                  str_len = str.length,
                  buf_len = 0;
                for (m_pos = 0; m_pos < str_len; m_pos++) {
                  c = str.charCodeAt(m_pos);
                  if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
                    c2 = str.charCodeAt(m_pos + 1);
                    if ((c2 & 64512) === 56320) {
                      c = 65536 + ((c - 55296) << 10) + (c2 - 56320);
                      m_pos++;
                    }
                  }
                  buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
                }
                if (support.uint8array) {
                  buf = new Uint8Array(buf_len);
                } else {
                  buf = new Array(buf_len);
                }
                for (i2 = 0, m_pos = 0; i2 < buf_len; m_pos++) {
                  c = str.charCodeAt(m_pos);
                  if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
                    c2 = str.charCodeAt(m_pos + 1);
                    if ((c2 & 64512) === 56320) {
                      c = 65536 + ((c - 55296) << 10) + (c2 - 56320);
                      m_pos++;
                    }
                  }
                  if (c < 128) {
                    buf[i2++] = c;
                  } else if (c < 2048) {
                    buf[i2++] = 192 | (c >>> 6);
                    buf[i2++] = 128 | (c & 63);
                  } else if (c < 65536) {
                    buf[i2++] = 224 | (c >>> 12);
                    buf[i2++] = 128 | ((c >>> 6) & 63);
                    buf[i2++] = 128 | (c & 63);
                  } else {
                    buf[i2++] = 240 | (c >>> 18);
                    buf[i2++] = 128 | ((c >>> 12) & 63);
                    buf[i2++] = 128 | ((c >>> 6) & 63);
                    buf[i2++] = 128 | (c & 63);
                  }
                }
                return buf;
              };
              var utf8border = function (buf, max) {
                var pos;
                max = max || buf.length;
                if (max > buf.length) {
                  max = buf.length;
                }
                pos = max - 1;
                while (pos >= 0 && (buf[pos] & 192) === 128) {
                  pos--;
                }
                if (pos < 0) {
                  return max;
                }
                if (pos === 0) {
                  return max;
                }
                return pos + _utf8len[buf[pos]] > max ? pos : max;
              };
              var buf2string = function (buf) {
                var str, i2, out, c, c_len;
                var len = buf.length;
                var utf16buf = new Array(len * 2);
                for (out = 0, i2 = 0; i2 < len; ) {
                  c = buf[i2++];
                  if (c < 128) {
                    utf16buf[out++] = c;
                    continue;
                  }
                  c_len = _utf8len[c];
                  if (c_len > 4) {
                    utf16buf[out++] = 65533;
                    i2 += c_len - 1;
                    continue;
                  }
                  c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
                  while (c_len > 1 && i2 < len) {
                    c = (c << 6) | (buf[i2++] & 63);
                    c_len--;
                  }
                  if (c_len > 1) {
                    utf16buf[out++] = 65533;
                    continue;
                  }
                  if (c < 65536) {
                    utf16buf[out++] = c;
                  } else {
                    c -= 65536;
                    utf16buf[out++] = 55296 | ((c >> 10) & 1023);
                    utf16buf[out++] = 56320 | (c & 1023);
                  }
                }
                if (utf16buf.length !== out) {
                  if (utf16buf.subarray) {
                    utf16buf = utf16buf.subarray(0, out);
                  } else {
                    utf16buf.length = out;
                  }
                }
                return utils.applyFromCharCode(utf16buf);
              };
              exports3.utf8encode = function utf8encode(str) {
                if (support.nodebuffer) {
                  return nodeBuffer(str, "utf-8");
                }
                return string2buf(str);
              };
              exports3.utf8decode = function utf8decode(buf) {
                if (support.nodebuffer) {
                  return utils.transformTo("nodebuffer", buf).toString("utf-8");
                }
                buf = utils.transformTo(
                  support.uint8array ? "uint8array" : "array",
                  buf
                );
                var result = [],
                  k = 0,
                  len = buf.length,
                  chunk = 65536;
                while (k < len) {
                  var nextBoundary = utf8border(buf, Math.min(k + chunk, len));
                  if (support.uint8array) {
                    result.push(buf2string(buf.subarray(k, nextBoundary)));
                  } else {
                    result.push(buf2string(buf.slice(k, nextBoundary)));
                  }
                  k = nextBoundary;
                }
                return result.join("");
              };
            },
            { "./nodeBuffer": 16, "./support": 22, "./utils": 26 },
          ],
          26: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var support = _dereq_("./support");
              var compressions = _dereq_("./compressions");
              var nodeBuffer = _dereq_("./nodeBuffer");
              exports3.string2binary = function (str) {
                var result = "";
                for (var i = 0; i < str.length; i++) {
                  result += String.fromCharCode(str.charCodeAt(i) & 255);
                }
                return result;
              };
              exports3.arrayBuffer2Blob = function (buffer, mimeType) {
                exports3.checkSupport("blob");
                mimeType = mimeType || "application/zip";
                try {
                  return new Blob([buffer], {
                    type: mimeType,
                  });
                } catch (e) {
                  try {
                    var Builder =
                      window.BlobBuilder ||
                      window.WebKitBlobBuilder ||
                      window.MozBlobBuilder ||
                      window.MSBlobBuilder;
                    var builder = new Builder();
                    builder.append(buffer);
                    return builder.getBlob(mimeType);
                  } catch (e2) {
                    throw new Error("Bug : can't construct the Blob.");
                  }
                }
              };
              function identity(input) {
                return input;
              }
              function stringToArrayLike(str, array) {
                for (var i = 0; i < str.length; ++i) {
                  array[i] = str.charCodeAt(i) & 255;
                }
                return array;
              }
              function arrayLikeToString(array) {
                var chunk = 65536;
                var result = [],
                  len = array.length,
                  type = exports3.getTypeOf(array),
                  k = 0,
                  canUseApply = true;
                try {
                  switch (type) {
                    case "uint8array":
                      String.fromCharCode.apply(null, new Uint8Array(0));
                      break;
                    case "nodebuffer":
                      String.fromCharCode.apply(null, nodeBuffer(0));
                      break;
                  }
                } catch (e) {
                  canUseApply = false;
                }
                if (!canUseApply) {
                  var resultStr = "";
                  for (var i = 0; i < array.length; i++) {
                    resultStr += String.fromCharCode(array[i]);
                  }
                  return resultStr;
                }
                while (k < len && chunk > 1) {
                  try {
                    if (type === "array" || type === "nodebuffer") {
                      result.push(
                        String.fromCharCode.apply(
                          null,
                          array.slice(k, Math.min(k + chunk, len))
                        )
                      );
                    } else {
                      result.push(
                        String.fromCharCode.apply(
                          null,
                          array.subarray(k, Math.min(k + chunk, len))
                        )
                      );
                    }
                    k += chunk;
                  } catch (e) {
                    chunk = Math.floor(chunk / 2);
                  }
                }
                return result.join("");
              }
              exports3.applyFromCharCode = arrayLikeToString;
              function arrayLikeToArrayLike(arrayFrom, arrayTo) {
                for (var i = 0; i < arrayFrom.length; i++) {
                  arrayTo[i] = arrayFrom[i];
                }
                return arrayTo;
              }
              var transform = {};
              transform["string"] = {
                string: identity,
                array: function (input) {
                  return stringToArrayLike(input, new Array(input.length));
                },
                arraybuffer: function (input) {
                  return transform["string"]["uint8array"](input).buffer;
                },
                uint8array: function (input) {
                  return stringToArrayLike(input, new Uint8Array(input.length));
                },
                nodebuffer: function (input) {
                  return stringToArrayLike(input, nodeBuffer(input.length));
                },
              };
              transform["array"] = {
                string: arrayLikeToString,
                array: identity,
                arraybuffer: function (input) {
                  return new Uint8Array(input).buffer;
                },
                uint8array: function (input) {
                  return new Uint8Array(input);
                },
                nodebuffer: function (input) {
                  return nodeBuffer(input);
                },
              };
              transform["arraybuffer"] = {
                string: function (input) {
                  return arrayLikeToString(new Uint8Array(input));
                },
                array: function (input) {
                  return arrayLikeToArrayLike(
                    new Uint8Array(input),
                    new Array(input.byteLength)
                  );
                },
                arraybuffer: identity,
                uint8array: function (input) {
                  return new Uint8Array(input);
                },
                nodebuffer: function (input) {
                  return nodeBuffer(new Uint8Array(input));
                },
              };
              transform["uint8array"] = {
                string: arrayLikeToString,
                array: function (input) {
                  return arrayLikeToArrayLike(input, new Array(input.length));
                },
                arraybuffer: function (input) {
                  return input.buffer;
                },
                uint8array: identity,
                nodebuffer: function (input) {
                  return nodeBuffer(input);
                },
              };
              transform["nodebuffer"] = {
                string: arrayLikeToString,
                array: function (input) {
                  return arrayLikeToArrayLike(input, new Array(input.length));
                },
                arraybuffer: function (input) {
                  return transform["nodebuffer"]["uint8array"](input).buffer;
                },
                uint8array: function (input) {
                  return arrayLikeToArrayLike(
                    input,
                    new Uint8Array(input.length)
                  );
                },
                nodebuffer: identity,
              };
              exports3.transformTo = function (outputType, input) {
                if (!input) {
                  input = "";
                }
                if (!outputType) {
                  return input;
                }
                exports3.checkSupport(outputType);
                var inputType = exports3.getTypeOf(input);
                var result = transform[inputType][outputType](input);
                return result;
              };
              exports3.getTypeOf = function (input) {
                if (typeof input === "string") {
                  return "string";
                }
                if (
                  Object.prototype.toString.call(input) === "[object Array]"
                ) {
                  return "array";
                }
                if (support.nodebuffer && nodeBuffer.test(input)) {
                  return "nodebuffer";
                }
                if (support.uint8array && input instanceof Uint8Array) {
                  return "uint8array";
                }
                if (support.arraybuffer && input instanceof ArrayBuffer) {
                  return "arraybuffer";
                }
              };
              exports3.checkSupport = function (type) {
                var supported = support[type.toLowerCase()];
                if (!supported) {
                  throw new Error(type + " is not supported by this browser");
                }
              };
              exports3.MAX_VALUE_16BITS = 65535;
              exports3.MAX_VALUE_32BITS = -1;
              exports3.pretty = function (str) {
                var res = "",
                  code,
                  i;
                for (i = 0; i < (str || "").length; i++) {
                  code = str.charCodeAt(i);
                  res +=
                    "\\x" +
                    (code < 16 ? "0" : "") +
                    code.toString(16).toUpperCase();
                }
                return res;
              };
              exports3.findCompression = function (compressionMethod) {
                for (var method in compressions) {
                  if (!compressions.hasOwnProperty(method)) {
                    continue;
                  }
                  if (compressions[method].magic === compressionMethod) {
                    return compressions[method];
                  }
                }
                return null;
              };
              exports3.isRegExp = function (object) {
                return (
                  Object.prototype.toString.call(object) === "[object RegExp]"
                );
              };
              exports3.extend = function () {
                var result = {},
                  i,
                  attr;
                for (i = 0; i < arguments.length; i++) {
                  for (attr in arguments[i]) {
                    if (
                      arguments[i].hasOwnProperty(attr) &&
                      typeof result[attr] === "undefined"
                    ) {
                      result[attr] = arguments[i][attr];
                    }
                  }
                }
                return result;
              };
            },
            { "./compressions": 8, "./nodeBuffer": 16, "./support": 22 },
          ],
          27: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var StringReader = _dereq_("./stringReader");
              var NodeBufferReader = _dereq_("./nodeBufferReader");
              var Uint8ArrayReader = _dereq_("./uint8ArrayReader");
              var ArrayReader = _dereq_("./arrayReader");
              var utils = _dereq_("./utils");
              var sig = _dereq_("./signature");
              var ZipEntry = _dereq_("./zipEntry");
              var support = _dereq_("./support");
              var jszipProto = _dereq_("./object");
              function ZipEntries(data, loadOptions) {
                this.files = [];
                this.loadOptions = loadOptions;
                if (data) {
                  this.load(data);
                }
              }
              ZipEntries.prototype = {
                /**
                 * Check that the reader is on the speficied signature.
                 * @param {string} expectedSignature the expected signature.
                 * @throws {Error} if it is an other signature.
                 */
                checkSignature: function (expectedSignature) {
                  var signature = this.reader.readString(4);
                  if (signature !== expectedSignature) {
                    throw new Error(
                      "Corrupted zip or bug : unexpected signature (" +
                        utils.pretty(signature) +
                        ", expected " +
                        utils.pretty(expectedSignature) +
                        ")"
                    );
                  }
                },
                /**
                 * Check if the given signature is at the given index.
                 * @param {number} askedIndex the index to check.
                 * @param {string} expectedSignature the signature to expect.
                 * @return {boolean} true if the signature is here, false otherwise.
                 */
                isSignature: function (askedIndex, expectedSignature) {
                  var currentIndex = this.reader.index;
                  this.reader.setIndex(askedIndex);
                  var signature = this.reader.readString(4);
                  var result = signature === expectedSignature;
                  this.reader.setIndex(currentIndex);
                  return result;
                },
                /**
                 * Read the end of the central directory.
                 */
                readBlockEndOfCentral: function () {
                  this.diskNumber = this.reader.readInt(2);
                  this.diskWithCentralDirStart = this.reader.readInt(2);
                  this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
                  this.centralDirRecords = this.reader.readInt(2);
                  this.centralDirSize = this.reader.readInt(4);
                  this.centralDirOffset = this.reader.readInt(4);
                  this.zipCommentLength = this.reader.readInt(2);
                  var zipComment = this.reader.readData(this.zipCommentLength);
                  var decodeParamType = support.uint8array
                    ? "uint8array"
                    : "array";
                  var decodeContent = utils.transformTo(
                    decodeParamType,
                    zipComment
                  );
                  this.zipComment =
                    this.loadOptions.decodeFileName(decodeContent);
                },
                /**
                 * Read the end of the Zip 64 central directory.
                 * Not merged with the method readEndOfCentral :
                 * The end of central can coexist with its Zip64 brother,
                 * I don't want to read the wrong number of bytes !
                 */
                readBlockZip64EndOfCentral: function () {
                  this.zip64EndOfCentralSize = this.reader.readInt(8);
                  this.versionMadeBy = this.reader.readString(2);
                  this.versionNeeded = this.reader.readInt(2);
                  this.diskNumber = this.reader.readInt(4);
                  this.diskWithCentralDirStart = this.reader.readInt(4);
                  this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
                  this.centralDirRecords = this.reader.readInt(8);
                  this.centralDirSize = this.reader.readInt(8);
                  this.centralDirOffset = this.reader.readInt(8);
                  this.zip64ExtensibleData = {};
                  var extraDataSize = this.zip64EndOfCentralSize - 44,
                    index = 0,
                    extraFieldId,
                    extraFieldLength,
                    extraFieldValue;
                  while (index < extraDataSize) {
                    extraFieldId = this.reader.readInt(2);
                    extraFieldLength = this.reader.readInt(4);
                    extraFieldValue = this.reader.readString(extraFieldLength);
                    this.zip64ExtensibleData[extraFieldId] = {
                      id: extraFieldId,
                      length: extraFieldLength,
                      value: extraFieldValue,
                    };
                  }
                },
                /**
                 * Read the end of the Zip 64 central directory locator.
                 */
                readBlockZip64EndOfCentralLocator: function () {
                  this.diskWithZip64CentralDirStart = this.reader.readInt(4);
                  this.relativeOffsetEndOfZip64CentralDir =
                    this.reader.readInt(8);
                  this.disksCount = this.reader.readInt(4);
                  if (this.disksCount > 1) {
                    throw new Error("Multi-volumes zip are not supported");
                  }
                },
                /**
                 * Read the local files, based on the offset read in the central part.
                 */
                readLocalFiles: function () {
                  var i, file;
                  for (i = 0; i < this.files.length; i++) {
                    file = this.files[i];
                    this.reader.setIndex(file.localHeaderOffset);
                    this.checkSignature(sig.LOCAL_FILE_HEADER);
                    file.readLocalPart(this.reader);
                    file.handleUTF8();
                    file.processAttributes();
                  }
                },
                /**
                 * Read the central directory.
                 */
                readCentralDir: function () {
                  var file;
                  this.reader.setIndex(this.centralDirOffset);
                  while (
                    this.reader.readString(4) === sig.CENTRAL_FILE_HEADER
                  ) {
                    file = new ZipEntry(
                      {
                        zip64: this.zip64,
                      },
                      this.loadOptions
                    );
                    file.readCentralPart(this.reader);
                    this.files.push(file);
                  }
                  if (this.centralDirRecords !== this.files.length) {
                    if (
                      this.centralDirRecords !== 0 &&
                      this.files.length === 0
                    ) {
                      throw new Error(
                        "Corrupted zip or bug: expected " +
                          this.centralDirRecords +
                          " records in central dir, got " +
                          this.files.length
                      );
                    } else {
                    }
                  }
                },
                /**
                 * Read the end of central directory.
                 */
                readEndOfCentral: function () {
                  var offset = this.reader.lastIndexOfSignature(
                    sig.CENTRAL_DIRECTORY_END
                  );
                  if (offset < 0) {
                    var isGarbage = !this.isSignature(0, sig.LOCAL_FILE_HEADER);
                    if (isGarbage) {
                      throw new Error(
                        "Can't find end of central directory : is this a zip file ? If it is, see http://stuk.github.io/jszip/documentation/howto/read_zip.html"
                      );
                    } else {
                      throw new Error(
                        "Corrupted zip : can't find end of central directory"
                      );
                    }
                  }
                  this.reader.setIndex(offset);
                  var endOfCentralDirOffset = offset;
                  this.checkSignature(sig.CENTRAL_DIRECTORY_END);
                  this.readBlockEndOfCentral();
                  if (
                    this.diskNumber === utils.MAX_VALUE_16BITS ||
                    this.diskWithCentralDirStart === utils.MAX_VALUE_16BITS ||
                    this.centralDirRecordsOnThisDisk ===
                      utils.MAX_VALUE_16BITS ||
                    this.centralDirRecords === utils.MAX_VALUE_16BITS ||
                    this.centralDirSize === utils.MAX_VALUE_32BITS ||
                    this.centralDirOffset === utils.MAX_VALUE_32BITS
                  ) {
                    this.zip64 = true;
                    offset = this.reader.lastIndexOfSignature(
                      sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR
                    );
                    if (offset < 0) {
                      throw new Error(
                        "Corrupted zip : can't find the ZIP64 end of central directory locator"
                      );
                    }
                    this.reader.setIndex(offset);
                    this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
                    this.readBlockZip64EndOfCentralLocator();
                    if (
                      !this.isSignature(
                        this.relativeOffsetEndOfZip64CentralDir,
                        sig.ZIP64_CENTRAL_DIRECTORY_END
                      )
                    ) {
                      this.relativeOffsetEndOfZip64CentralDir =
                        this.reader.lastIndexOfSignature(
                          sig.ZIP64_CENTRAL_DIRECTORY_END
                        );
                      if (this.relativeOffsetEndOfZip64CentralDir < 0) {
                        throw new Error(
                          "Corrupted zip : can't find the ZIP64 end of central directory"
                        );
                      }
                    }
                    this.reader.setIndex(
                      this.relativeOffsetEndOfZip64CentralDir
                    );
                    this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
                    this.readBlockZip64EndOfCentral();
                  }
                  var expectedEndOfCentralDirOffset =
                    this.centralDirOffset + this.centralDirSize;
                  if (this.zip64) {
                    expectedEndOfCentralDirOffset += 20;
                    expectedEndOfCentralDirOffset +=
                      12 + this.zip64EndOfCentralSize;
                  }
                  var extraBytes =
                    endOfCentralDirOffset - expectedEndOfCentralDirOffset;
                  if (extraBytes > 0) {
                    if (
                      this.isSignature(
                        endOfCentralDirOffset,
                        sig.CENTRAL_FILE_HEADER
                      )
                    ) {
                    } else {
                      this.reader.zero = extraBytes;
                    }
                  } else if (extraBytes < 0) {
                    throw new Error(
                      "Corrupted zip: missing " +
                        Math.abs(extraBytes) +
                        " bytes."
                    );
                  }
                },
                prepareReader: function (data) {
                  var type = utils.getTypeOf(data);
                  utils.checkSupport(type);
                  if (type === "string" && !support.uint8array) {
                    this.reader = new StringReader(
                      data,
                      this.loadOptions.optimizedBinaryString
                    );
                  } else if (type === "nodebuffer") {
                    this.reader = new NodeBufferReader(data);
                  } else if (support.uint8array) {
                    this.reader = new Uint8ArrayReader(
                      utils.transformTo("uint8array", data)
                    );
                  } else if (support.array) {
                    this.reader = new ArrayReader(
                      utils.transformTo("array", data)
                    );
                  } else {
                    throw new Error(
                      "Unexpected error: unsupported type '" + type + "'"
                    );
                  }
                },
                /**
                 * Read a zip file and create ZipEntries.
                 * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
                 */
                load: function (data) {
                  this.prepareReader(data);
                  this.readEndOfCentral();
                  this.readCentralDir();
                  this.readLocalFiles();
                },
              };
              module3.exports = ZipEntries;
            },
            {
              "./arrayReader": 5,
              "./nodeBufferReader": 17,
              "./object": 18,
              "./signature": 19,
              "./stringReader": 20,
              "./support": 22,
              "./uint8ArrayReader": 23,
              "./utils": 26,
              "./zipEntry": 28,
            },
          ],
          28: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var StringReader = _dereq_("./stringReader");
              var utils = _dereq_("./utils");
              var CompressedObject = _dereq_("./compressedObject");
              var jszipProto = _dereq_("./object");
              var support = _dereq_("./support");
              var MADE_BY_DOS = 0;
              var MADE_BY_UNIX = 3;
              function ZipEntry(options, loadOptions) {
                this.options = options;
                this.loadOptions = loadOptions;
              }
              ZipEntry.prototype = {
                /**
                 * say if the file is encrypted.
                 * @return {boolean} true if the file is encrypted, false otherwise.
                 */
                isEncrypted: function () {
                  return (this.bitFlag & 1) === 1;
                },
                /**
                 * say if the file has utf-8 filename/comment.
                 * @return {boolean} true if the filename/comment is in utf-8, false otherwise.
                 */
                useUTF8: function () {
                  return (this.bitFlag & 2048) === 2048;
                },
                /**
                 * Prepare the function used to generate the compressed content from this ZipFile.
                 * @param {DataReader} reader the reader to use.
                 * @param {number} from the offset from where we should read the data.
                 * @param {number} length the length of the data to read.
                 * @return {Function} the callback to get the compressed content (the type depends of the DataReader class).
                 */
                prepareCompressedContent: function (reader, from, length) {
                  return function () {
                    var previousIndex = reader.index;
                    reader.setIndex(from);
                    var compressedFileData = reader.readData(length);
                    reader.setIndex(previousIndex);
                    return compressedFileData;
                  };
                },
                /**
                 * Prepare the function used to generate the uncompressed content from this ZipFile.
                 * @param {DataReader} reader the reader to use.
                 * @param {number} from the offset from where we should read the data.
                 * @param {number} length the length of the data to read.
                 * @param {JSZip.compression} compression the compression used on this file.
                 * @param {number} uncompressedSize the uncompressed size to expect.
                 * @return {Function} the callback to get the uncompressed content (the type depends of the DataReader class).
                 */
                prepareContent: function (
                  reader,
                  from,
                  length,
                  compression,
                  uncompressedSize
                ) {
                  return function () {
                    var compressedFileData = utils.transformTo(
                      compression.uncompressInputType,
                      this.getCompressedContent()
                    );
                    var uncompressedFileData =
                      compression.uncompress(compressedFileData);
                    if (uncompressedFileData.length !== uncompressedSize) {
                      throw new Error("Bug : uncompressed data size mismatch");
                    }
                    return uncompressedFileData;
                  };
                },
                /**
                 * Read the local part of a zip file and add the info in this object.
                 * @param {DataReader} reader the reader to use.
                 */
                readLocalPart: function (reader) {
                  var compression, localExtraFieldsLength;
                  reader.skip(22);
                  this.fileNameLength = reader.readInt(2);
                  localExtraFieldsLength = reader.readInt(2);
                  this.fileName = reader.readData(this.fileNameLength);
                  reader.skip(localExtraFieldsLength);
                  if (
                    this.compressedSize == -1 ||
                    this.uncompressedSize == -1
                  ) {
                    throw new Error(
                      "Bug or corrupted zip : didn't get enough informations from the central directory (compressedSize == -1 || uncompressedSize == -1)"
                    );
                  }
                  compression = utils.findCompression(this.compressionMethod);
                  if (compression === null) {
                    throw new Error(
                      "Corrupted zip : compression " +
                        utils.pretty(this.compressionMethod) +
                        " unknown (inner file : " +
                        utils.transformTo("string", this.fileName) +
                        ")"
                    );
                  }
                  this.decompressed = new CompressedObject();
                  this.decompressed.compressedSize = this.compressedSize;
                  this.decompressed.uncompressedSize = this.uncompressedSize;
                  this.decompressed.crc32 = this.crc32;
                  this.decompressed.compressionMethod = this.compressionMethod;
                  this.decompressed.getCompressedContent =
                    this.prepareCompressedContent(
                      reader,
                      reader.index,
                      this.compressedSize,
                      compression
                    );
                  this.decompressed.getContent = this.prepareContent(
                    reader,
                    reader.index,
                    this.compressedSize,
                    compression,
                    this.uncompressedSize
                  );
                  if (this.loadOptions.checkCRC32) {
                    this.decompressed = utils.transformTo(
                      "string",
                      this.decompressed.getContent()
                    );
                    if (jszipProto.crc32(this.decompressed) !== this.crc32) {
                      throw new Error("Corrupted zip : CRC32 mismatch");
                    }
                  }
                },
                /**
                 * Read the central part of a zip file and add the info in this object.
                 * @param {DataReader} reader the reader to use.
                 */
                readCentralPart: function (reader) {
                  this.versionMadeBy = reader.readInt(2);
                  this.versionNeeded = reader.readInt(2);
                  this.bitFlag = reader.readInt(2);
                  this.compressionMethod = reader.readString(2);
                  this.date = reader.readDate();
                  this.crc32 = reader.readInt(4);
                  this.compressedSize = reader.readInt(4);
                  this.uncompressedSize = reader.readInt(4);
                  this.fileNameLength = reader.readInt(2);
                  this.extraFieldsLength = reader.readInt(2);
                  this.fileCommentLength = reader.readInt(2);
                  this.diskNumberStart = reader.readInt(2);
                  this.internalFileAttributes = reader.readInt(2);
                  this.externalFileAttributes = reader.readInt(4);
                  this.localHeaderOffset = reader.readInt(4);
                  if (this.isEncrypted()) {
                    throw new Error("Encrypted zip are not supported");
                  }
                  this.fileName = reader.readData(this.fileNameLength);
                  this.readExtraFields(reader);
                  this.parseZIP64ExtraField(reader);
                  this.fileComment = reader.readData(this.fileCommentLength);
                },
                /**
                 * Parse the external file attributes and get the unix/dos permissions.
                 */
                processAttributes: function () {
                  this.unixPermissions = null;
                  this.dosPermissions = null;
                  var madeBy = this.versionMadeBy >> 8;
                  this.dir = this.externalFileAttributes & 16 ? true : false;
                  if (madeBy === MADE_BY_DOS) {
                    this.dosPermissions = this.externalFileAttributes & 63;
                  }
                  if (madeBy === MADE_BY_UNIX) {
                    this.unixPermissions =
                      (this.externalFileAttributes >> 16) & 65535;
                  }
                  if (!this.dir && this.fileNameStr.slice(-1) === "/") {
                    this.dir = true;
                  }
                },
                /**
                 * Parse the ZIP64 extra field and merge the info in the current ZipEntry.
                 * @param {DataReader} reader the reader to use.
                 */
                parseZIP64ExtraField: function (reader) {
                  if (!this.extraFields[1]) {
                    return;
                  }
                  var extraReader = new StringReader(this.extraFields[1].value);
                  if (this.uncompressedSize === utils.MAX_VALUE_32BITS) {
                    this.uncompressedSize = extraReader.readInt(8);
                  }
                  if (this.compressedSize === utils.MAX_VALUE_32BITS) {
                    this.compressedSize = extraReader.readInt(8);
                  }
                  if (this.localHeaderOffset === utils.MAX_VALUE_32BITS) {
                    this.localHeaderOffset = extraReader.readInt(8);
                  }
                  if (this.diskNumberStart === utils.MAX_VALUE_32BITS) {
                    this.diskNumberStart = extraReader.readInt(4);
                  }
                },
                /**
                 * Read the central part of a zip file and add the info in this object.
                 * @param {DataReader} reader the reader to use.
                 */
                readExtraFields: function (reader) {
                  var start = reader.index,
                    extraFieldId,
                    extraFieldLength,
                    extraFieldValue;
                  this.extraFields = this.extraFields || {};
                  while (reader.index < start + this.extraFieldsLength) {
                    extraFieldId = reader.readInt(2);
                    extraFieldLength = reader.readInt(2);
                    extraFieldValue = reader.readString(extraFieldLength);
                    this.extraFields[extraFieldId] = {
                      id: extraFieldId,
                      length: extraFieldLength,
                      value: extraFieldValue,
                    };
                  }
                },
                /**
                 * Apply an UTF8 transformation if needed.
                 */
                handleUTF8: function () {
                  var decodeParamType = support.uint8array
                    ? "uint8array"
                    : "array";
                  if (this.useUTF8()) {
                    this.fileNameStr = jszipProto.utf8decode(this.fileName);
                    this.fileCommentStr = jszipProto.utf8decode(
                      this.fileComment
                    );
                  } else {
                    var upath = this.findExtraFieldUnicodePath();
                    if (upath !== null) {
                      this.fileNameStr = upath;
                    } else {
                      var fileNameByteArray = utils.transformTo(
                        decodeParamType,
                        this.fileName
                      );
                      this.fileNameStr =
                        this.loadOptions.decodeFileName(fileNameByteArray);
                    }
                    var ucomment = this.findExtraFieldUnicodeComment();
                    if (ucomment !== null) {
                      this.fileCommentStr = ucomment;
                    } else {
                      var commentByteArray = utils.transformTo(
                        decodeParamType,
                        this.fileComment
                      );
                      this.fileCommentStr =
                        this.loadOptions.decodeFileName(commentByteArray);
                    }
                  }
                },
                /**
                 * Find the unicode path declared in the extra field, if any.
                 * @return {String} the unicode path, null otherwise.
                 */
                findExtraFieldUnicodePath: function () {
                  var upathField = this.extraFields[28789];
                  if (upathField) {
                    var extraReader = new StringReader(upathField.value);
                    if (extraReader.readInt(1) !== 1) {
                      return null;
                    }
                    if (
                      jszipProto.crc32(this.fileName) !== extraReader.readInt(4)
                    ) {
                      return null;
                    }
                    return jszipProto.utf8decode(
                      extraReader.readString(upathField.length - 5)
                    );
                  }
                  return null;
                },
                /**
                 * Find the unicode comment declared in the extra field, if any.
                 * @return {String} the unicode comment, null otherwise.
                 */
                findExtraFieldUnicodeComment: function () {
                  var ucommentField = this.extraFields[25461];
                  if (ucommentField) {
                    var extraReader = new StringReader(ucommentField.value);
                    if (extraReader.readInt(1) !== 1) {
                      return null;
                    }
                    if (
                      jszipProto.crc32(this.fileComment) !==
                      extraReader.readInt(4)
                    ) {
                      return null;
                    }
                    return jszipProto.utf8decode(
                      extraReader.readString(ucommentField.length - 5)
                    );
                  }
                  return null;
                },
              };
              module3.exports = ZipEntry;
            },
            {
              "./compressedObject": 7,
              "./object": 18,
              "./stringReader": 20,
              "./support": 22,
              "./utils": 26,
            },
          ],
          29: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var assign = _dereq_("./lib/utils/common").assign;
              var deflate = _dereq_("./lib/deflate");
              var inflate = _dereq_("./lib/inflate");
              var constants = _dereq_("./lib/zlib/constants");
              var pako = {};
              assign(pako, deflate, inflate, constants);
              module3.exports = pako;
            },
            {
              "./lib/deflate": 30,
              "./lib/inflate": 31,
              "./lib/utils/common": 32,
              "./lib/zlib/constants": 35,
            },
          ],
          30: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var zlib_deflate = _dereq_("./zlib/deflate");
              var utils = _dereq_("./utils/common");
              var strings = _dereq_("./utils/strings");
              var msg = _dereq_("./zlib/messages");
              var ZStream = _dereq_("./zlib/zstream");
              var toString = Object.prototype.toString;
              var Z_NO_FLUSH = 0;
              var Z_FINISH = 4;
              var Z_OK = 0;
              var Z_STREAM_END = 1;
              var Z_SYNC_FLUSH = 2;
              var Z_DEFAULT_COMPRESSION = -1;
              var Z_DEFAULT_STRATEGY = 0;
              var Z_DEFLATED = 8;
              function Deflate(options) {
                if (!(this instanceof Deflate)) return new Deflate(options);
                this.options = utils.assign(
                  {
                    level: Z_DEFAULT_COMPRESSION,
                    method: Z_DEFLATED,
                    chunkSize: 16384,
                    windowBits: 15,
                    memLevel: 8,
                    strategy: Z_DEFAULT_STRATEGY,
                    to: "",
                  },
                  options || {}
                );
                var opt = this.options;
                if (opt.raw && opt.windowBits > 0) {
                  opt.windowBits = -opt.windowBits;
                } else if (
                  opt.gzip &&
                  opt.windowBits > 0 &&
                  opt.windowBits < 16
                ) {
                  opt.windowBits += 16;
                }
                this.err = 0;
                this.msg = "";
                this.ended = false;
                this.chunks = [];
                this.strm = new ZStream();
                this.strm.avail_out = 0;
                var status = zlib_deflate.deflateInit2(
                  this.strm,
                  opt.level,
                  opt.method,
                  opt.windowBits,
                  opt.memLevel,
                  opt.strategy
                );
                if (status !== Z_OK) {
                  throw new Error(msg[status]);
                }
                if (opt.header) {
                  zlib_deflate.deflateSetHeader(this.strm, opt.header);
                }
                if (opt.dictionary) {
                  var dict;
                  if (typeof opt.dictionary === "string") {
                    dict = strings.string2buf(opt.dictionary);
                  } else if (
                    toString.call(opt.dictionary) === "[object ArrayBuffer]"
                  ) {
                    dict = new Uint8Array(opt.dictionary);
                  } else {
                    dict = opt.dictionary;
                  }
                  status = zlib_deflate.deflateSetDictionary(this.strm, dict);
                  if (status !== Z_OK) {
                    throw new Error(msg[status]);
                  }
                  this._dict_set = true;
                }
              }
              Deflate.prototype.push = function (data, mode) {
                var strm = this.strm;
                var chunkSize = this.options.chunkSize;
                var status, _mode;
                if (this.ended) {
                  return false;
                }
                _mode =
                  mode === ~~mode
                    ? mode
                    : mode === true
                    ? Z_FINISH
                    : Z_NO_FLUSH;
                if (typeof data === "string") {
                  strm.input = strings.string2buf(data);
                } else if (toString.call(data) === "[object ArrayBuffer]") {
                  strm.input = new Uint8Array(data);
                } else {
                  strm.input = data;
                }
                strm.next_in = 0;
                strm.avail_in = strm.input.length;
                do {
                  if (strm.avail_out === 0) {
                    strm.output = new utils.Buf8(chunkSize);
                    strm.next_out = 0;
                    strm.avail_out = chunkSize;
                  }
                  status = zlib_deflate.deflate(strm, _mode);
                  if (status !== Z_STREAM_END && status !== Z_OK) {
                    this.onEnd(status);
                    this.ended = true;
                    return false;
                  }
                  if (
                    strm.avail_out === 0 ||
                    (strm.avail_in === 0 &&
                      (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH))
                  ) {
                    if (this.options.to === "string") {
                      this.onData(
                        strings.buf2binstring(
                          utils.shrinkBuf(strm.output, strm.next_out)
                        )
                      );
                    } else {
                      this.onData(utils.shrinkBuf(strm.output, strm.next_out));
                    }
                  }
                } while (
                  (strm.avail_in > 0 || strm.avail_out === 0) &&
                  status !== Z_STREAM_END
                );
                if (_mode === Z_FINISH) {
                  status = zlib_deflate.deflateEnd(this.strm);
                  this.onEnd(status);
                  this.ended = true;
                  return status === Z_OK;
                }
                if (_mode === Z_SYNC_FLUSH) {
                  this.onEnd(Z_OK);
                  strm.avail_out = 0;
                  return true;
                }
                return true;
              };
              Deflate.prototype.onData = function (chunk) {
                this.chunks.push(chunk);
              };
              Deflate.prototype.onEnd = function (status) {
                if (status === Z_OK) {
                  if (this.options.to === "string") {
                    this.result = this.chunks.join("");
                  } else {
                    this.result = utils.flattenChunks(this.chunks);
                  }
                }
                this.chunks = [];
                this.err = status;
                this.msg = this.strm.msg;
              };
              function deflate(input, options) {
                var deflator = new Deflate(options);
                deflator.push(input, true);
                if (deflator.err) {
                  throw deflator.msg;
                }
                return deflator.result;
              }
              function deflateRaw(input, options) {
                options = options || {};
                options.raw = true;
                return deflate(input, options);
              }
              function gzip(input, options) {
                options = options || {};
                options.gzip = true;
                return deflate(input, options);
              }
              exports3.Deflate = Deflate;
              exports3.deflate = deflate;
              exports3.deflateRaw = deflateRaw;
              exports3.gzip = gzip;
            },
            {
              "./utils/common": 32,
              "./utils/strings": 33,
              "./zlib/deflate": 37,
              "./zlib/messages": 42,
              "./zlib/zstream": 44,
            },
          ],
          31: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var zlib_inflate = _dereq_("./zlib/inflate");
              var utils = _dereq_("./utils/common");
              var strings = _dereq_("./utils/strings");
              var c = _dereq_("./zlib/constants");
              var msg = _dereq_("./zlib/messages");
              var ZStream = _dereq_("./zlib/zstream");
              var GZheader = _dereq_("./zlib/gzheader");
              var toString = Object.prototype.toString;
              function Inflate(options) {
                if (!(this instanceof Inflate)) return new Inflate(options);
                this.options = utils.assign(
                  {
                    chunkSize: 16384,
                    windowBits: 0,
                    to: "",
                  },
                  options || {}
                );
                var opt = this.options;
                if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
                  opt.windowBits = -opt.windowBits;
                  if (opt.windowBits === 0) {
                    opt.windowBits = -15;
                  }
                }
                if (
                  opt.windowBits >= 0 &&
                  opt.windowBits < 16 &&
                  !(options && options.windowBits)
                ) {
                  opt.windowBits += 32;
                }
                if (opt.windowBits > 15 && opt.windowBits < 48) {
                  if ((opt.windowBits & 15) === 0) {
                    opt.windowBits |= 15;
                  }
                }
                this.err = 0;
                this.msg = "";
                this.ended = false;
                this.chunks = [];
                this.strm = new ZStream();
                this.strm.avail_out = 0;
                var status = zlib_inflate.inflateInit2(
                  this.strm,
                  opt.windowBits
                );
                if (status !== c.Z_OK) {
                  throw new Error(msg[status]);
                }
                this.header = new GZheader();
                zlib_inflate.inflateGetHeader(this.strm, this.header);
              }
              Inflate.prototype.push = function (data, mode) {
                var strm = this.strm;
                var chunkSize = this.options.chunkSize;
                var dictionary = this.options.dictionary;
                var status, _mode;
                var next_out_utf8, tail, utf8str;
                var dict;
                var allowBufError = false;
                if (this.ended) {
                  return false;
                }
                _mode =
                  mode === ~~mode
                    ? mode
                    : mode === true
                    ? c.Z_FINISH
                    : c.Z_NO_FLUSH;
                if (typeof data === "string") {
                  strm.input = strings.binstring2buf(data);
                } else if (toString.call(data) === "[object ArrayBuffer]") {
                  strm.input = new Uint8Array(data);
                } else {
                  strm.input = data;
                }
                strm.next_in = 0;
                strm.avail_in = strm.input.length;
                do {
                  if (strm.avail_out === 0) {
                    strm.output = new utils.Buf8(chunkSize);
                    strm.next_out = 0;
                    strm.avail_out = chunkSize;
                  }
                  status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);
                  if (status === c.Z_NEED_DICT && dictionary) {
                    if (typeof dictionary === "string") {
                      dict = strings.string2buf(dictionary);
                    } else if (
                      toString.call(dictionary) === "[object ArrayBuffer]"
                    ) {
                      dict = new Uint8Array(dictionary);
                    } else {
                      dict = dictionary;
                    }
                    status = zlib_inflate.inflateSetDictionary(this.strm, dict);
                  }
                  if (status === c.Z_BUF_ERROR && allowBufError === true) {
                    status = c.Z_OK;
                    allowBufError = false;
                  }
                  if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
                    this.onEnd(status);
                    this.ended = true;
                    return false;
                  }
                  if (strm.next_out) {
                    if (
                      strm.avail_out === 0 ||
                      status === c.Z_STREAM_END ||
                      (strm.avail_in === 0 &&
                        (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))
                    ) {
                      if (this.options.to === "string") {
                        next_out_utf8 = strings.utf8border(
                          strm.output,
                          strm.next_out
                        );
                        tail = strm.next_out - next_out_utf8;
                        utf8str = strings.buf2string(
                          strm.output,
                          next_out_utf8
                        );
                        strm.next_out = tail;
                        strm.avail_out = chunkSize - tail;
                        if (tail) {
                          utils.arraySet(
                            strm.output,
                            strm.output,
                            next_out_utf8,
                            tail,
                            0
                          );
                        }
                        this.onData(utf8str);
                      } else {
                        this.onData(
                          utils.shrinkBuf(strm.output, strm.next_out)
                        );
                      }
                    }
                  }
                  if (strm.avail_in === 0 && strm.avail_out === 0) {
                    allowBufError = true;
                  }
                } while (
                  (strm.avail_in > 0 || strm.avail_out === 0) &&
                  status !== c.Z_STREAM_END
                );
                if (status === c.Z_STREAM_END) {
                  _mode = c.Z_FINISH;
                }
                if (_mode === c.Z_FINISH) {
                  status = zlib_inflate.inflateEnd(this.strm);
                  this.onEnd(status);
                  this.ended = true;
                  return status === c.Z_OK;
                }
                if (_mode === c.Z_SYNC_FLUSH) {
                  this.onEnd(c.Z_OK);
                  strm.avail_out = 0;
                  return true;
                }
                return true;
              };
              Inflate.prototype.onData = function (chunk) {
                this.chunks.push(chunk);
              };
              Inflate.prototype.onEnd = function (status) {
                if (status === c.Z_OK) {
                  if (this.options.to === "string") {
                    this.result = this.chunks.join("");
                  } else {
                    this.result = utils.flattenChunks(this.chunks);
                  }
                }
                this.chunks = [];
                this.err = status;
                this.msg = this.strm.msg;
              };
              function inflate(input, options) {
                var inflator = new Inflate(options);
                inflator.push(input, true);
                if (inflator.err) {
                  throw inflator.msg;
                }
                return inflator.result;
              }
              function inflateRaw(input, options) {
                options = options || {};
                options.raw = true;
                return inflate(input, options);
              }
              exports3.Inflate = Inflate;
              exports3.inflate = inflate;
              exports3.inflateRaw = inflateRaw;
              exports3.ungzip = inflate;
            },
            {
              "./utils/common": 32,
              "./utils/strings": 33,
              "./zlib/constants": 35,
              "./zlib/gzheader": 38,
              "./zlib/inflate": 40,
              "./zlib/messages": 42,
              "./zlib/zstream": 44,
            },
          ],
          32: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var TYPED_OK =
                typeof Uint8Array !== "undefined" &&
                typeof Uint16Array !== "undefined" &&
                typeof Int32Array !== "undefined";
              exports3.assign = function (obj) {
                var sources = Array.prototype.slice.call(arguments, 1);
                while (sources.length) {
                  var source = sources.shift();
                  if (!source) {
                    continue;
                  }
                  if (typeof source !== "object") {
                    throw new TypeError(source + "must be non-object");
                  }
                  for (var p in source) {
                    if (source.hasOwnProperty(p)) {
                      obj[p] = source[p];
                    }
                  }
                }
                return obj;
              };
              exports3.shrinkBuf = function (buf, size) {
                if (buf.length === size) {
                  return buf;
                }
                if (buf.subarray) {
                  return buf.subarray(0, size);
                }
                buf.length = size;
                return buf;
              };
              var fnTyped = {
                arraySet: function (dest, src, src_offs, len, dest_offs) {
                  if (src.subarray && dest.subarray) {
                    dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
                    return;
                  }
                  for (var i = 0; i < len; i++) {
                    dest[dest_offs + i] = src[src_offs + i];
                  }
                },
                // Join array of chunks to single array.
                flattenChunks: function (chunks) {
                  var i, l, len, pos, chunk, result;
                  len = 0;
                  for (i = 0, l = chunks.length; i < l; i++) {
                    len += chunks[i].length;
                  }
                  result = new Uint8Array(len);
                  pos = 0;
                  for (i = 0, l = chunks.length; i < l; i++) {
                    chunk = chunks[i];
                    result.set(chunk, pos);
                    pos += chunk.length;
                  }
                  return result;
                },
              };
              var fnUntyped = {
                arraySet: function (dest, src, src_offs, len, dest_offs) {
                  for (var i = 0; i < len; i++) {
                    dest[dest_offs + i] = src[src_offs + i];
                  }
                },
                // Join array of chunks to single array.
                flattenChunks: function (chunks) {
                  return [].concat.apply([], chunks);
                },
              };
              exports3.setTyped = function (on) {
                if (on) {
                  exports3.Buf8 = Uint8Array;
                  exports3.Buf16 = Uint16Array;
                  exports3.Buf32 = Int32Array;
                  exports3.assign(exports3, fnTyped);
                } else {
                  exports3.Buf8 = Array;
                  exports3.Buf16 = Array;
                  exports3.Buf32 = Array;
                  exports3.assign(exports3, fnUntyped);
                }
              };
              exports3.setTyped(TYPED_OK);
            },
            {},
          ],
          33: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("./common");
              var STR_APPLY_OK = true;
              var STR_APPLY_UIA_OK = true;
              try {
                String.fromCharCode.apply(null, [0]);
              } catch (__) {
                STR_APPLY_OK = false;
              }
              try {
                String.fromCharCode.apply(null, new Uint8Array(1));
              } catch (__) {
                STR_APPLY_UIA_OK = false;
              }
              var _utf8len = new utils.Buf8(256);
              for (var q = 0; q < 256; q++) {
                _utf8len[q] =
                  q >= 252
                    ? 6
                    : q >= 248
                    ? 5
                    : q >= 240
                    ? 4
                    : q >= 224
                    ? 3
                    : q >= 192
                    ? 2
                    : 1;
              }
              _utf8len[254] = _utf8len[254] = 1;
              exports3.string2buf = function (str) {
                var buf,
                  c,
                  c2,
                  m_pos,
                  i,
                  str_len = str.length,
                  buf_len = 0;
                for (m_pos = 0; m_pos < str_len; m_pos++) {
                  c = str.charCodeAt(m_pos);
                  if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
                    c2 = str.charCodeAt(m_pos + 1);
                    if ((c2 & 64512) === 56320) {
                      c = 65536 + ((c - 55296) << 10) + (c2 - 56320);
                      m_pos++;
                    }
                  }
                  buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
                }
                buf = new utils.Buf8(buf_len);
                for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
                  c = str.charCodeAt(m_pos);
                  if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
                    c2 = str.charCodeAt(m_pos + 1);
                    if ((c2 & 64512) === 56320) {
                      c = 65536 + ((c - 55296) << 10) + (c2 - 56320);
                      m_pos++;
                    }
                  }
                  if (c < 128) {
                    buf[i++] = c;
                  } else if (c < 2048) {
                    buf[i++] = 192 | (c >>> 6);
                    buf[i++] = 128 | (c & 63);
                  } else if (c < 65536) {
                    buf[i++] = 224 | (c >>> 12);
                    buf[i++] = 128 | ((c >>> 6) & 63);
                    buf[i++] = 128 | (c & 63);
                  } else {
                    buf[i++] = 240 | (c >>> 18);
                    buf[i++] = 128 | ((c >>> 12) & 63);
                    buf[i++] = 128 | ((c >>> 6) & 63);
                    buf[i++] = 128 | (c & 63);
                  }
                }
                return buf;
              };
              function buf2binstring(buf, len) {
                if (len < 65537) {
                  if (
                    (buf.subarray && STR_APPLY_UIA_OK) ||
                    (!buf.subarray && STR_APPLY_OK)
                  ) {
                    return String.fromCharCode.apply(
                      null,
                      utils.shrinkBuf(buf, len)
                    );
                  }
                }
                var result = "";
                for (var i = 0; i < len; i++) {
                  result += String.fromCharCode(buf[i]);
                }
                return result;
              }
              exports3.buf2binstring = function (buf) {
                return buf2binstring(buf, buf.length);
              };
              exports3.binstring2buf = function (str) {
                var buf = new utils.Buf8(str.length);
                for (var i = 0, len = buf.length; i < len; i++) {
                  buf[i] = str.charCodeAt(i);
                }
                return buf;
              };
              exports3.buf2string = function (buf, max) {
                var i, out, c, c_len;
                var len = max || buf.length;
                var utf16buf = new Array(len * 2);
                for (out = 0, i = 0; i < len; ) {
                  c = buf[i++];
                  if (c < 128) {
                    utf16buf[out++] = c;
                    continue;
                  }
                  c_len = _utf8len[c];
                  if (c_len > 4) {
                    utf16buf[out++] = 65533;
                    i += c_len - 1;
                    continue;
                  }
                  c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
                  while (c_len > 1 && i < len) {
                    c = (c << 6) | (buf[i++] & 63);
                    c_len--;
                  }
                  if (c_len > 1) {
                    utf16buf[out++] = 65533;
                    continue;
                  }
                  if (c < 65536) {
                    utf16buf[out++] = c;
                  } else {
                    c -= 65536;
                    utf16buf[out++] = 55296 | ((c >> 10) & 1023);
                    utf16buf[out++] = 56320 | (c & 1023);
                  }
                }
                return buf2binstring(utf16buf, out);
              };
              exports3.utf8border = function (buf, max) {
                var pos;
                max = max || buf.length;
                if (max > buf.length) {
                  max = buf.length;
                }
                pos = max - 1;
                while (pos >= 0 && (buf[pos] & 192) === 128) {
                  pos--;
                }
                if (pos < 0) {
                  return max;
                }
                if (pos === 0) {
                  return max;
                }
                return pos + _utf8len[buf[pos]] > max ? pos : max;
              };
            },
            { "./common": 32 },
          ],
          34: [
            function (_dereq_, module3, exports3) {
              "use strict";
              function adler32(adler, buf, len, pos) {
                var s1 = (adler & 65535) | 0,
                  s2 = ((adler >>> 16) & 65535) | 0,
                  n = 0;
                while (len !== 0) {
                  n = len > 2e3 ? 2e3 : len;
                  len -= n;
                  do {
                    s1 = (s1 + buf[pos++]) | 0;
                    s2 = (s2 + s1) | 0;
                  } while (--n);
                  s1 %= 65521;
                  s2 %= 65521;
                }
                return s1 | (s2 << 16) | 0;
              }
              module3.exports = adler32;
            },
            {},
          ],
          35: [
            function (_dereq_, module3, exports3) {
              "use strict";
              module3.exports = {
                /* Allowed flush values; see deflate() and inflate() below for details */
                Z_NO_FLUSH: 0,
                Z_PARTIAL_FLUSH: 1,
                Z_SYNC_FLUSH: 2,
                Z_FULL_FLUSH: 3,
                Z_FINISH: 4,
                Z_BLOCK: 5,
                Z_TREES: 6,
                /* Return codes for the compression/decompression functions. Negative values
                 * are errors, positive values are used for special but normal events.
                 */
                Z_OK: 0,
                Z_STREAM_END: 1,
                Z_NEED_DICT: 2,
                Z_ERRNO: -1,
                Z_STREAM_ERROR: -2,
                Z_DATA_ERROR: -3,
                //Z_MEM_ERROR:     -4,
                Z_BUF_ERROR: -5,
                //Z_VERSION_ERROR: -6,
                /* compression levels */
                Z_NO_COMPRESSION: 0,
                Z_BEST_SPEED: 1,
                Z_BEST_COMPRESSION: 9,
                Z_DEFAULT_COMPRESSION: -1,
                Z_FILTERED: 1,
                Z_HUFFMAN_ONLY: 2,
                Z_RLE: 3,
                Z_FIXED: 4,
                Z_DEFAULT_STRATEGY: 0,
                /* Possible values of the data_type field (though see inflate()) */
                Z_BINARY: 0,
                Z_TEXT: 1,
                //Z_ASCII:                1, // = Z_TEXT (deprecated)
                Z_UNKNOWN: 2,
                /* The deflate compression method */
                Z_DEFLATED: 8,
                //Z_NULL:                 null // Use -1 or null inline, depending on var type
              };
            },
            {},
          ],
          36: [
            function (_dereq_, module3, exports3) {
              "use strict";
              function makeTable() {
                var c,
                  table = [];
                for (var n = 0; n < 256; n++) {
                  c = n;
                  for (var k = 0; k < 8; k++) {
                    c = c & 1 ? 3988292384 ^ (c >>> 1) : c >>> 1;
                  }
                  table[n] = c;
                }
                return table;
              }
              var crcTable = makeTable();
              function crc32(crc, buf, len, pos) {
                var t = crcTable,
                  end = pos + len;
                crc ^= -1;
                for (var i = pos; i < end; i++) {
                  crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 255];
                }
                return crc ^ -1;
              }
              module3.exports = crc32;
            },
            {},
          ],
          37: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("../utils/common");
              var trees = _dereq_("./trees");
              var adler32 = _dereq_("./adler32");
              var crc32 = _dereq_("./crc32");
              var msg = _dereq_("./messages");
              var Z_NO_FLUSH = 0;
              var Z_PARTIAL_FLUSH = 1;
              var Z_FULL_FLUSH = 3;
              var Z_FINISH = 4;
              var Z_BLOCK = 5;
              var Z_OK = 0;
              var Z_STREAM_END = 1;
              var Z_STREAM_ERROR = -2;
              var Z_DATA_ERROR = -3;
              var Z_BUF_ERROR = -5;
              var Z_DEFAULT_COMPRESSION = -1;
              var Z_FILTERED = 1;
              var Z_HUFFMAN_ONLY = 2;
              var Z_RLE = 3;
              var Z_FIXED = 4;
              var Z_DEFAULT_STRATEGY = 0;
              var Z_UNKNOWN = 2;
              var Z_DEFLATED = 8;
              var MAX_MEM_LEVEL = 9;
              var MAX_WBITS = 15;
              var DEF_MEM_LEVEL = 8;
              var LENGTH_CODES = 29;
              var LITERALS = 256;
              var L_CODES = LITERALS + 1 + LENGTH_CODES;
              var D_CODES = 30;
              var BL_CODES = 19;
              var HEAP_SIZE = 2 * L_CODES + 1;
              var MAX_BITS = 15;
              var MIN_MATCH = 3;
              var MAX_MATCH = 258;
              var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
              var PRESET_DICT = 32;
              var INIT_STATE = 42;
              var EXTRA_STATE = 69;
              var NAME_STATE = 73;
              var COMMENT_STATE = 91;
              var HCRC_STATE = 103;
              var BUSY_STATE = 113;
              var FINISH_STATE = 666;
              var BS_NEED_MORE = 1;
              var BS_BLOCK_DONE = 2;
              var BS_FINISH_STARTED = 3;
              var BS_FINISH_DONE = 4;
              var OS_CODE = 3;
              function err(strm, errorCode) {
                strm.msg = msg[errorCode];
                return errorCode;
              }
              function rank(f) {
                return (f << 1) - (f > 4 ? 9 : 0);
              }
              function zero(buf) {
                var len = buf.length;
                while (--len >= 0) {
                  buf[len] = 0;
                }
              }
              function flush_pending(strm) {
                var s = strm.state;
                var len = s.pending;
                if (len > strm.avail_out) {
                  len = strm.avail_out;
                }
                if (len === 0) {
                  return;
                }
                utils.arraySet(
                  strm.output,
                  s.pending_buf,
                  s.pending_out,
                  len,
                  strm.next_out
                );
                strm.next_out += len;
                s.pending_out += len;
                strm.total_out += len;
                strm.avail_out -= len;
                s.pending -= len;
                if (s.pending === 0) {
                  s.pending_out = 0;
                }
              }
              function flush_block_only(s, last) {
                trees._tr_flush_block(
                  s,
                  s.block_start >= 0 ? s.block_start : -1,
                  s.strstart - s.block_start,
                  last
                );
                s.block_start = s.strstart;
                flush_pending(s.strm);
              }
              function put_byte(s, b) {
                s.pending_buf[s.pending++] = b;
              }
              function putShortMSB(s, b) {
                s.pending_buf[s.pending++] = (b >>> 8) & 255;
                s.pending_buf[s.pending++] = b & 255;
              }
              function read_buf(strm, buf, start, size) {
                var len = strm.avail_in;
                if (len > size) {
                  len = size;
                }
                if (len === 0) {
                  return 0;
                }
                strm.avail_in -= len;
                utils.arraySet(buf, strm.input, strm.next_in, len, start);
                if (strm.state.wrap === 1) {
                  strm.adler = adler32(strm.adler, buf, len, start);
                } else if (strm.state.wrap === 2) {
                  strm.adler = crc32(strm.adler, buf, len, start);
                }
                strm.next_in += len;
                strm.total_in += len;
                return len;
              }
              function longest_match(s, cur_match) {
                var chain_length = s.max_chain_length;
                var scan = s.strstart;
                var match;
                var len;
                var best_len = s.prev_length;
                var nice_match = s.nice_match;
                var limit =
                  s.strstart > s.w_size - MIN_LOOKAHEAD
                    ? s.strstart - (s.w_size - MIN_LOOKAHEAD)
                    : 0;
                var _win = s.window;
                var wmask = s.w_mask;
                var prev = s.prev;
                var strend = s.strstart + MAX_MATCH;
                var scan_end1 = _win[scan + best_len - 1];
                var scan_end = _win[scan + best_len];
                if (s.prev_length >= s.good_match) {
                  chain_length >>= 2;
                }
                if (nice_match > s.lookahead) {
                  nice_match = s.lookahead;
                }
                do {
                  match = cur_match;
                  if (
                    _win[match + best_len] !== scan_end ||
                    _win[match + best_len - 1] !== scan_end1 ||
                    _win[match] !== _win[scan] ||
                    _win[++match] !== _win[scan + 1]
                  ) {
                    continue;
                  }
                  scan += 2;
                  match++;
                  do {} while (
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    _win[++scan] === _win[++match] &&
                    scan < strend
                  );
                  len = MAX_MATCH - (strend - scan);
                  scan = strend - MAX_MATCH;
                  if (len > best_len) {
                    s.match_start = cur_match;
                    best_len = len;
                    if (len >= nice_match) {
                      break;
                    }
                    scan_end1 = _win[scan + best_len - 1];
                    scan_end = _win[scan + best_len];
                  }
                } while (
                  (cur_match = prev[cur_match & wmask]) > limit &&
                  --chain_length !== 0
                );
                if (best_len <= s.lookahead) {
                  return best_len;
                }
                return s.lookahead;
              }
              function fill_window(s) {
                var _w_size = s.w_size;
                var p, n, m, more, str;
                do {
                  more = s.window_size - s.lookahead - s.strstart;
                  if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
                    utils.arraySet(s.window, s.window, _w_size, _w_size, 0);
                    s.match_start -= _w_size;
                    s.strstart -= _w_size;
                    s.block_start -= _w_size;
                    n = s.hash_size;
                    p = n;
                    do {
                      m = s.head[--p];
                      s.head[p] = m >= _w_size ? m - _w_size : 0;
                    } while (--n);
                    n = _w_size;
                    p = n;
                    do {
                      m = s.prev[--p];
                      s.prev[p] = m >= _w_size ? m - _w_size : 0;
                    } while (--n);
                    more += _w_size;
                  }
                  if (s.strm.avail_in === 0) {
                    break;
                  }
                  n = read_buf(
                    s.strm,
                    s.window,
                    s.strstart + s.lookahead,
                    more
                  );
                  s.lookahead += n;
                  if (s.lookahead + s.insert >= MIN_MATCH) {
                    str = s.strstart - s.insert;
                    s.ins_h = s.window[str];
                    s.ins_h =
                      ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) &
                      s.hash_mask;
                    while (s.insert) {
                      s.ins_h =
                        ((s.ins_h << s.hash_shift) ^
                          s.window[str + MIN_MATCH - 1]) &
                        s.hash_mask;
                      s.prev[str & s.w_mask] = s.head[s.ins_h];
                      s.head[s.ins_h] = str;
                      str++;
                      s.insert--;
                      if (s.lookahead + s.insert < MIN_MATCH) {
                        break;
                      }
                    }
                  }
                } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
              }
              function deflate_stored(s, flush) {
                var max_block_size = 65535;
                if (max_block_size > s.pending_buf_size - 5) {
                  max_block_size = s.pending_buf_size - 5;
                }
                for (;;) {
                  if (s.lookahead <= 1) {
                    fill_window(s);
                    if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
                      return BS_NEED_MORE;
                    }
                    if (s.lookahead === 0) {
                      break;
                    }
                  }
                  s.strstart += s.lookahead;
                  s.lookahead = 0;
                  var max_start = s.block_start + max_block_size;
                  if (s.strstart === 0 || s.strstart >= max_start) {
                    s.lookahead = s.strstart - max_start;
                    s.strstart = max_start;
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  }
                  if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  }
                }
                s.insert = 0;
                if (flush === Z_FINISH) {
                  flush_block_only(s, true);
                  if (s.strm.avail_out === 0) {
                    return BS_FINISH_STARTED;
                  }
                  return BS_FINISH_DONE;
                }
                if (s.strstart > s.block_start) {
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                }
                return BS_NEED_MORE;
              }
              function deflate_fast(s, flush) {
                var hash_head;
                var bflush;
                for (;;) {
                  if (s.lookahead < MIN_LOOKAHEAD) {
                    fill_window(s);
                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
                      return BS_NEED_MORE;
                    }
                    if (s.lookahead === 0) {
                      break;
                    }
                  }
                  hash_head = 0;
                  if (s.lookahead >= MIN_MATCH) {
                    s.ins_h =
                      ((s.ins_h << s.hash_shift) ^
                        s.window[s.strstart + MIN_MATCH - 1]) &
                      s.hash_mask;
                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                    s.head[s.ins_h] = s.strstart;
                  }
                  if (
                    hash_head !== 0 &&
                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD
                  ) {
                    s.match_length = longest_match(s, hash_head);
                  }
                  if (s.match_length >= MIN_MATCH) {
                    bflush = trees._tr_tally(
                      s,
                      s.strstart - s.match_start,
                      s.match_length - MIN_MATCH
                    );
                    s.lookahead -= s.match_length;
                    if (
                      s.match_length <= s.max_lazy_match &&
                      s.lookahead >= MIN_MATCH
                    ) {
                      s.match_length--;
                      do {
                        s.strstart++;
                        s.ins_h =
                          ((s.ins_h << s.hash_shift) ^
                            s.window[s.strstart + MIN_MATCH - 1]) &
                          s.hash_mask;
                        hash_head = s.prev[s.strstart & s.w_mask] =
                          s.head[s.ins_h];
                        s.head[s.ins_h] = s.strstart;
                      } while (--s.match_length !== 0);
                      s.strstart++;
                    } else {
                      s.strstart += s.match_length;
                      s.match_length = 0;
                      s.ins_h = s.window[s.strstart];
                      s.ins_h =
                        ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) &
                        s.hash_mask;
                    }
                  } else {
                    bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
                    s.lookahead--;
                    s.strstart++;
                  }
                  if (bflush) {
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  }
                }
                s.insert =
                  s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
                if (flush === Z_FINISH) {
                  flush_block_only(s, true);
                  if (s.strm.avail_out === 0) {
                    return BS_FINISH_STARTED;
                  }
                  return BS_FINISH_DONE;
                }
                if (s.last_lit) {
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                }
                return BS_BLOCK_DONE;
              }
              function deflate_slow(s, flush) {
                var hash_head;
                var bflush;
                var max_insert;
                for (;;) {
                  if (s.lookahead < MIN_LOOKAHEAD) {
                    fill_window(s);
                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
                      return BS_NEED_MORE;
                    }
                    if (s.lookahead === 0) {
                      break;
                    }
                  }
                  hash_head = 0;
                  if (s.lookahead >= MIN_MATCH) {
                    s.ins_h =
                      ((s.ins_h << s.hash_shift) ^
                        s.window[s.strstart + MIN_MATCH - 1]) &
                      s.hash_mask;
                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
                    s.head[s.ins_h] = s.strstart;
                  }
                  s.prev_length = s.match_length;
                  s.prev_match = s.match_start;
                  s.match_length = MIN_MATCH - 1;
                  if (
                    hash_head !== 0 &&
                    s.prev_length < s.max_lazy_match &&
                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD
                  ) {
                    s.match_length = longest_match(s, hash_head);
                    if (
                      s.match_length <= 5 &&
                      (s.strategy === Z_FILTERED ||
                        (s.match_length === MIN_MATCH &&
                          s.strstart - s.match_start > 4096))
                    ) {
                      s.match_length = MIN_MATCH - 1;
                    }
                  }
                  if (
                    s.prev_length >= MIN_MATCH &&
                    s.match_length <= s.prev_length
                  ) {
                    max_insert = s.strstart + s.lookahead - MIN_MATCH;
                    bflush = trees._tr_tally(
                      s,
                      s.strstart - 1 - s.prev_match,
                      s.prev_length - MIN_MATCH
                    );
                    s.lookahead -= s.prev_length - 1;
                    s.prev_length -= 2;
                    do {
                      if (++s.strstart <= max_insert) {
                        s.ins_h =
                          ((s.ins_h << s.hash_shift) ^
                            s.window[s.strstart + MIN_MATCH - 1]) &
                          s.hash_mask;
                        hash_head = s.prev[s.strstart & s.w_mask] =
                          s.head[s.ins_h];
                        s.head[s.ins_h] = s.strstart;
                      }
                    } while (--s.prev_length !== 0);
                    s.match_available = 0;
                    s.match_length = MIN_MATCH - 1;
                    s.strstart++;
                    if (bflush) {
                      flush_block_only(s, false);
                      if (s.strm.avail_out === 0) {
                        return BS_NEED_MORE;
                      }
                    }
                  } else if (s.match_available) {
                    bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
                    if (bflush) {
                      flush_block_only(s, false);
                    }
                    s.strstart++;
                    s.lookahead--;
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  } else {
                    s.match_available = 1;
                    s.strstart++;
                    s.lookahead--;
                  }
                }
                if (s.match_available) {
                  bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]);
                  s.match_available = 0;
                }
                s.insert =
                  s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
                if (flush === Z_FINISH) {
                  flush_block_only(s, true);
                  if (s.strm.avail_out === 0) {
                    return BS_FINISH_STARTED;
                  }
                  return BS_FINISH_DONE;
                }
                if (s.last_lit) {
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                }
                return BS_BLOCK_DONE;
              }
              function deflate_rle(s, flush) {
                var bflush;
                var prev;
                var scan, strend;
                var _win = s.window;
                for (;;) {
                  if (s.lookahead <= MAX_MATCH) {
                    fill_window(s);
                    if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
                      return BS_NEED_MORE;
                    }
                    if (s.lookahead === 0) {
                      break;
                    }
                  }
                  s.match_length = 0;
                  if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
                    scan = s.strstart - 1;
                    prev = _win[scan];
                    if (
                      prev === _win[++scan] &&
                      prev === _win[++scan] &&
                      prev === _win[++scan]
                    ) {
                      strend = s.strstart + MAX_MATCH;
                      do {} while (
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        prev === _win[++scan] &&
                        scan < strend
                      );
                      s.match_length = MAX_MATCH - (strend - scan);
                      if (s.match_length > s.lookahead) {
                        s.match_length = s.lookahead;
                      }
                    }
                  }
                  if (s.match_length >= MIN_MATCH) {
                    bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH);
                    s.lookahead -= s.match_length;
                    s.strstart += s.match_length;
                    s.match_length = 0;
                  } else {
                    bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
                    s.lookahead--;
                    s.strstart++;
                  }
                  if (bflush) {
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  }
                }
                s.insert = 0;
                if (flush === Z_FINISH) {
                  flush_block_only(s, true);
                  if (s.strm.avail_out === 0) {
                    return BS_FINISH_STARTED;
                  }
                  return BS_FINISH_DONE;
                }
                if (s.last_lit) {
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                }
                return BS_BLOCK_DONE;
              }
              function deflate_huff(s, flush) {
                var bflush;
                for (;;) {
                  if (s.lookahead === 0) {
                    fill_window(s);
                    if (s.lookahead === 0) {
                      if (flush === Z_NO_FLUSH) {
                        return BS_NEED_MORE;
                      }
                      break;
                    }
                  }
                  s.match_length = 0;
                  bflush = trees._tr_tally(s, 0, s.window[s.strstart]);
                  s.lookahead--;
                  s.strstart++;
                  if (bflush) {
                    flush_block_only(s, false);
                    if (s.strm.avail_out === 0) {
                      return BS_NEED_MORE;
                    }
                  }
                }
                s.insert = 0;
                if (flush === Z_FINISH) {
                  flush_block_only(s, true);
                  if (s.strm.avail_out === 0) {
                    return BS_FINISH_STARTED;
                  }
                  return BS_FINISH_DONE;
                }
                if (s.last_lit) {
                  flush_block_only(s, false);
                  if (s.strm.avail_out === 0) {
                    return BS_NEED_MORE;
                  }
                }
                return BS_BLOCK_DONE;
              }
              function Config(
                good_length,
                max_lazy,
                nice_length,
                max_chain,
                func
              ) {
                this.good_length = good_length;
                this.max_lazy = max_lazy;
                this.nice_length = nice_length;
                this.max_chain = max_chain;
                this.func = func;
              }
              var configuration_table;
              configuration_table = [
                /*      good lazy nice chain */
                new Config(0, 0, 0, 0, deflate_stored),
                /* 0 store only */
                new Config(4, 4, 8, 4, deflate_fast),
                /* 1 max speed, no lazy matches */
                new Config(4, 5, 16, 8, deflate_fast),
                /* 2 */
                new Config(4, 6, 32, 32, deflate_fast),
                /* 3 */
                new Config(4, 4, 16, 16, deflate_slow),
                /* 4 lazy matches */
                new Config(8, 16, 32, 32, deflate_slow),
                /* 5 */
                new Config(8, 16, 128, 128, deflate_slow),
                /* 6 */
                new Config(8, 32, 128, 256, deflate_slow),
                /* 7 */
                new Config(32, 128, 258, 1024, deflate_slow),
                /* 8 */
                new Config(32, 258, 258, 4096, deflate_slow),
                /* 9 max compression */
              ];
              function lm_init(s) {
                s.window_size = 2 * s.w_size;
                zero(s.head);
                s.max_lazy_match = configuration_table[s.level].max_lazy;
                s.good_match = configuration_table[s.level].good_length;
                s.nice_match = configuration_table[s.level].nice_length;
                s.max_chain_length = configuration_table[s.level].max_chain;
                s.strstart = 0;
                s.block_start = 0;
                s.lookahead = 0;
                s.insert = 0;
                s.match_length = s.prev_length = MIN_MATCH - 1;
                s.match_available = 0;
                s.ins_h = 0;
              }
              function DeflateState() {
                this.strm = null;
                this.status = 0;
                this.pending_buf = null;
                this.pending_buf_size = 0;
                this.pending_out = 0;
                this.pending = 0;
                this.wrap = 0;
                this.gzhead = null;
                this.gzindex = 0;
                this.method = Z_DEFLATED;
                this.last_flush = -1;
                this.w_size = 0;
                this.w_bits = 0;
                this.w_mask = 0;
                this.window = null;
                this.window_size = 0;
                this.prev = null;
                this.head = null;
                this.ins_h = 0;
                this.hash_size = 0;
                this.hash_bits = 0;
                this.hash_mask = 0;
                this.hash_shift = 0;
                this.block_start = 0;
                this.match_length = 0;
                this.prev_match = 0;
                this.match_available = 0;
                this.strstart = 0;
                this.match_start = 0;
                this.lookahead = 0;
                this.prev_length = 0;
                this.max_chain_length = 0;
                this.max_lazy_match = 0;
                this.level = 0;
                this.strategy = 0;
                this.good_match = 0;
                this.nice_match = 0;
                this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2);
                this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2);
                this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2);
                zero(this.dyn_ltree);
                zero(this.dyn_dtree);
                zero(this.bl_tree);
                this.l_desc = null;
                this.d_desc = null;
                this.bl_desc = null;
                this.bl_count = new utils.Buf16(MAX_BITS + 1);
                this.heap = new utils.Buf16(2 * L_CODES + 1);
                zero(this.heap);
                this.heap_len = 0;
                this.heap_max = 0;
                this.depth = new utils.Buf16(2 * L_CODES + 1);
                zero(this.depth);
                this.l_buf = 0;
                this.lit_bufsize = 0;
                this.last_lit = 0;
                this.d_buf = 0;
                this.opt_len = 0;
                this.static_len = 0;
                this.matches = 0;
                this.insert = 0;
                this.bi_buf = 0;
                this.bi_valid = 0;
              }
              function deflateResetKeep(strm) {
                var s;
                if (!strm || !strm.state) {
                  return err(strm, Z_STREAM_ERROR);
                }
                strm.total_in = strm.total_out = 0;
                strm.data_type = Z_UNKNOWN;
                s = strm.state;
                s.pending = 0;
                s.pending_out = 0;
                if (s.wrap < 0) {
                  s.wrap = -s.wrap;
                }
                s.status = s.wrap ? INIT_STATE : BUSY_STATE;
                strm.adler = s.wrap === 2 ? 0 : 1;
                s.last_flush = Z_NO_FLUSH;
                trees._tr_init(s);
                return Z_OK;
              }
              function deflateReset(strm) {
                var ret = deflateResetKeep(strm);
                if (ret === Z_OK) {
                  lm_init(strm.state);
                }
                return ret;
              }
              function deflateSetHeader(strm, head) {
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                if (strm.state.wrap !== 2) {
                  return Z_STREAM_ERROR;
                }
                strm.state.gzhead = head;
                return Z_OK;
              }
              function deflateInit2(
                strm,
                level,
                method,
                windowBits,
                memLevel,
                strategy
              ) {
                if (!strm) {
                  return Z_STREAM_ERROR;
                }
                var wrap = 1;
                if (level === Z_DEFAULT_COMPRESSION) {
                  level = 6;
                }
                if (windowBits < 0) {
                  wrap = 0;
                  windowBits = -windowBits;
                } else if (windowBits > 15) {
                  wrap = 2;
                  windowBits -= 16;
                }
                if (
                  memLevel < 1 ||
                  memLevel > MAX_MEM_LEVEL ||
                  method !== Z_DEFLATED ||
                  windowBits < 8 ||
                  windowBits > 15 ||
                  level < 0 ||
                  level > 9 ||
                  strategy < 0 ||
                  strategy > Z_FIXED
                ) {
                  return err(strm, Z_STREAM_ERROR);
                }
                if (windowBits === 8) {
                  windowBits = 9;
                }
                var s = new DeflateState();
                strm.state = s;
                s.strm = strm;
                s.wrap = wrap;
                s.gzhead = null;
                s.w_bits = windowBits;
                s.w_size = 1 << s.w_bits;
                s.w_mask = s.w_size - 1;
                s.hash_bits = memLevel + 7;
                s.hash_size = 1 << s.hash_bits;
                s.hash_mask = s.hash_size - 1;
                s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
                s.window = new utils.Buf8(s.w_size * 2);
                s.head = new utils.Buf16(s.hash_size);
                s.prev = new utils.Buf16(s.w_size);
                s.lit_bufsize = 1 << (memLevel + 6);
                s.pending_buf_size = s.lit_bufsize * 4;
                s.pending_buf = new utils.Buf8(s.pending_buf_size);
                s.d_buf = s.lit_bufsize >> 1;
                s.l_buf = (1 + 2) * s.lit_bufsize;
                s.level = level;
                s.strategy = strategy;
                s.method = method;
                return deflateReset(strm);
              }
              function deflateInit(strm, level) {
                return deflateInit2(
                  strm,
                  level,
                  Z_DEFLATED,
                  MAX_WBITS,
                  DEF_MEM_LEVEL,
                  Z_DEFAULT_STRATEGY
                );
              }
              function deflate(strm, flush) {
                var old_flush, s;
                var beg, val;
                if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {
                  return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
                }
                s = strm.state;
                if (
                  !strm.output ||
                  (!strm.input && strm.avail_in !== 0) ||
                  (s.status === FINISH_STATE && flush !== Z_FINISH)
                ) {
                  return err(
                    strm,
                    strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR
                  );
                }
                s.strm = strm;
                old_flush = s.last_flush;
                s.last_flush = flush;
                if (s.status === INIT_STATE) {
                  if (s.wrap === 2) {
                    strm.adler = 0;
                    put_byte(s, 31);
                    put_byte(s, 139);
                    put_byte(s, 8);
                    if (!s.gzhead) {
                      put_byte(s, 0);
                      put_byte(s, 0);
                      put_byte(s, 0);
                      put_byte(s, 0);
                      put_byte(s, 0);
                      put_byte(
                        s,
                        s.level === 9
                          ? 2
                          : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2
                          ? 4
                          : 0
                      );
                      put_byte(s, OS_CODE);
                      s.status = BUSY_STATE;
                    } else {
                      put_byte(
                        s,
                        (s.gzhead.text ? 1 : 0) +
                          (s.gzhead.hcrc ? 2 : 0) +
                          (!s.gzhead.extra ? 0 : 4) +
                          (!s.gzhead.name ? 0 : 8) +
                          (!s.gzhead.comment ? 0 : 16)
                      );
                      put_byte(s, s.gzhead.time & 255);
                      put_byte(s, (s.gzhead.time >> 8) & 255);
                      put_byte(s, (s.gzhead.time >> 16) & 255);
                      put_byte(s, (s.gzhead.time >> 24) & 255);
                      put_byte(
                        s,
                        s.level === 9
                          ? 2
                          : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2
                          ? 4
                          : 0
                      );
                      put_byte(s, s.gzhead.os & 255);
                      if (s.gzhead.extra && s.gzhead.extra.length) {
                        put_byte(s, s.gzhead.extra.length & 255);
                        put_byte(s, (s.gzhead.extra.length >> 8) & 255);
                      }
                      if (s.gzhead.hcrc) {
                        strm.adler = crc32(
                          strm.adler,
                          s.pending_buf,
                          s.pending,
                          0
                        );
                      }
                      s.gzindex = 0;
                      s.status = EXTRA_STATE;
                    }
                  } else {
                    var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;
                    var level_flags = -1;
                    if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
                      level_flags = 0;
                    } else if (s.level < 6) {
                      level_flags = 1;
                    } else if (s.level === 6) {
                      level_flags = 2;
                    } else {
                      level_flags = 3;
                    }
                    header |= level_flags << 6;
                    if (s.strstart !== 0) {
                      header |= PRESET_DICT;
                    }
                    header += 31 - (header % 31);
                    s.status = BUSY_STATE;
                    putShortMSB(s, header);
                    if (s.strstart !== 0) {
                      putShortMSB(s, strm.adler >>> 16);
                      putShortMSB(s, strm.adler & 65535);
                    }
                    strm.adler = 1;
                  }
                }
                if (s.status === EXTRA_STATE) {
                  if (s.gzhead.extra) {
                    beg = s.pending;
                    while (s.gzindex < (s.gzhead.extra.length & 65535)) {
                      if (s.pending === s.pending_buf_size) {
                        if (s.gzhead.hcrc && s.pending > beg) {
                          strm.adler = crc32(
                            strm.adler,
                            s.pending_buf,
                            s.pending - beg,
                            beg
                          );
                        }
                        flush_pending(strm);
                        beg = s.pending;
                        if (s.pending === s.pending_buf_size) {
                          break;
                        }
                      }
                      put_byte(s, s.gzhead.extra[s.gzindex] & 255);
                      s.gzindex++;
                    }
                    if (s.gzhead.hcrc && s.pending > beg) {
                      strm.adler = crc32(
                        strm.adler,
                        s.pending_buf,
                        s.pending - beg,
                        beg
                      );
                    }
                    if (s.gzindex === s.gzhead.extra.length) {
                      s.gzindex = 0;
                      s.status = NAME_STATE;
                    }
                  } else {
                    s.status = NAME_STATE;
                  }
                }
                if (s.status === NAME_STATE) {
                  if (s.gzhead.name) {
                    beg = s.pending;
                    do {
                      if (s.pending === s.pending_buf_size) {
                        if (s.gzhead.hcrc && s.pending > beg) {
                          strm.adler = crc32(
                            strm.adler,
                            s.pending_buf,
                            s.pending - beg,
                            beg
                          );
                        }
                        flush_pending(strm);
                        beg = s.pending;
                        if (s.pending === s.pending_buf_size) {
                          val = 1;
                          break;
                        }
                      }
                      if (s.gzindex < s.gzhead.name.length) {
                        val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;
                      } else {
                        val = 0;
                      }
                      put_byte(s, val);
                    } while (val !== 0);
                    if (s.gzhead.hcrc && s.pending > beg) {
                      strm.adler = crc32(
                        strm.adler,
                        s.pending_buf,
                        s.pending - beg,
                        beg
                      );
                    }
                    if (val === 0) {
                      s.gzindex = 0;
                      s.status = COMMENT_STATE;
                    }
                  } else {
                    s.status = COMMENT_STATE;
                  }
                }
                if (s.status === COMMENT_STATE) {
                  if (s.gzhead.comment) {
                    beg = s.pending;
                    do {
                      if (s.pending === s.pending_buf_size) {
                        if (s.gzhead.hcrc && s.pending > beg) {
                          strm.adler = crc32(
                            strm.adler,
                            s.pending_buf,
                            s.pending - beg,
                            beg
                          );
                        }
                        flush_pending(strm);
                        beg = s.pending;
                        if (s.pending === s.pending_buf_size) {
                          val = 1;
                          break;
                        }
                      }
                      if (s.gzindex < s.gzhead.comment.length) {
                        val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;
                      } else {
                        val = 0;
                      }
                      put_byte(s, val);
                    } while (val !== 0);
                    if (s.gzhead.hcrc && s.pending > beg) {
                      strm.adler = crc32(
                        strm.adler,
                        s.pending_buf,
                        s.pending - beg,
                        beg
                      );
                    }
                    if (val === 0) {
                      s.status = HCRC_STATE;
                    }
                  } else {
                    s.status = HCRC_STATE;
                  }
                }
                if (s.status === HCRC_STATE) {
                  if (s.gzhead.hcrc) {
                    if (s.pending + 2 > s.pending_buf_size) {
                      flush_pending(strm);
                    }
                    if (s.pending + 2 <= s.pending_buf_size) {
                      put_byte(s, strm.adler & 255);
                      put_byte(s, (strm.adler >> 8) & 255);
                      strm.adler = 0;
                      s.status = BUSY_STATE;
                    }
                  } else {
                    s.status = BUSY_STATE;
                  }
                }
                if (s.pending !== 0) {
                  flush_pending(strm);
                  if (strm.avail_out === 0) {
                    s.last_flush = -1;
                    return Z_OK;
                  }
                } else if (
                  strm.avail_in === 0 &&
                  rank(flush) <= rank(old_flush) &&
                  flush !== Z_FINISH
                ) {
                  return err(strm, Z_BUF_ERROR);
                }
                if (s.status === FINISH_STATE && strm.avail_in !== 0) {
                  return err(strm, Z_BUF_ERROR);
                }
                if (
                  strm.avail_in !== 0 ||
                  s.lookahead !== 0 ||
                  (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)
                ) {
                  var bstate =
                    s.strategy === Z_HUFFMAN_ONLY
                      ? deflate_huff(s, flush)
                      : s.strategy === Z_RLE
                      ? deflate_rle(s, flush)
                      : configuration_table[s.level].func(s, flush);
                  if (
                    bstate === BS_FINISH_STARTED ||
                    bstate === BS_FINISH_DONE
                  ) {
                    s.status = FINISH_STATE;
                  }
                  if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
                    if (strm.avail_out === 0) {
                      s.last_flush = -1;
                    }
                    return Z_OK;
                  }
                  if (bstate === BS_BLOCK_DONE) {
                    if (flush === Z_PARTIAL_FLUSH) {
                      trees._tr_align(s);
                    } else if (flush !== Z_BLOCK) {
                      trees._tr_stored_block(s, 0, 0, false);
                      if (flush === Z_FULL_FLUSH) {
                        zero(s.head);
                        if (s.lookahead === 0) {
                          s.strstart = 0;
                          s.block_start = 0;
                          s.insert = 0;
                        }
                      }
                    }
                    flush_pending(strm);
                    if (strm.avail_out === 0) {
                      s.last_flush = -1;
                      return Z_OK;
                    }
                  }
                }
                if (flush !== Z_FINISH) {
                  return Z_OK;
                }
                if (s.wrap <= 0) {
                  return Z_STREAM_END;
                }
                if (s.wrap === 2) {
                  put_byte(s, strm.adler & 255);
                  put_byte(s, (strm.adler >> 8) & 255);
                  put_byte(s, (strm.adler >> 16) & 255);
                  put_byte(s, (strm.adler >> 24) & 255);
                  put_byte(s, strm.total_in & 255);
                  put_byte(s, (strm.total_in >> 8) & 255);
                  put_byte(s, (strm.total_in >> 16) & 255);
                  put_byte(s, (strm.total_in >> 24) & 255);
                } else {
                  putShortMSB(s, strm.adler >>> 16);
                  putShortMSB(s, strm.adler & 65535);
                }
                flush_pending(strm);
                if (s.wrap > 0) {
                  s.wrap = -s.wrap;
                }
                return s.pending !== 0 ? Z_OK : Z_STREAM_END;
              }
              function deflateEnd(strm) {
                var status;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                status = strm.state.status;
                if (
                  status !== INIT_STATE &&
                  status !== EXTRA_STATE &&
                  status !== NAME_STATE &&
                  status !== COMMENT_STATE &&
                  status !== HCRC_STATE &&
                  status !== BUSY_STATE &&
                  status !== FINISH_STATE
                ) {
                  return err(strm, Z_STREAM_ERROR);
                }
                strm.state = null;
                return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
              }
              function deflateSetDictionary(strm, dictionary) {
                var dictLength = dictionary.length;
                var s;
                var str, n;
                var wrap;
                var avail;
                var next;
                var input;
                var tmpDict;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                s = strm.state;
                wrap = s.wrap;
                if (
                  wrap === 2 ||
                  (wrap === 1 && s.status !== INIT_STATE) ||
                  s.lookahead
                ) {
                  return Z_STREAM_ERROR;
                }
                if (wrap === 1) {
                  strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
                }
                s.wrap = 0;
                if (dictLength >= s.w_size) {
                  if (wrap === 0) {
                    zero(s.head);
                    s.strstart = 0;
                    s.block_start = 0;
                    s.insert = 0;
                  }
                  tmpDict = new utils.Buf8(s.w_size);
                  utils.arraySet(
                    tmpDict,
                    dictionary,
                    dictLength - s.w_size,
                    s.w_size,
                    0
                  );
                  dictionary = tmpDict;
                  dictLength = s.w_size;
                }
                avail = strm.avail_in;
                next = strm.next_in;
                input = strm.input;
                strm.avail_in = dictLength;
                strm.next_in = 0;
                strm.input = dictionary;
                fill_window(s);
                while (s.lookahead >= MIN_MATCH) {
                  str = s.strstart;
                  n = s.lookahead - (MIN_MATCH - 1);
                  do {
                    s.ins_h =
                      ((s.ins_h << s.hash_shift) ^
                        s.window[str + MIN_MATCH - 1]) &
                      s.hash_mask;
                    s.prev[str & s.w_mask] = s.head[s.ins_h];
                    s.head[s.ins_h] = str;
                    str++;
                  } while (--n);
                  s.strstart = str;
                  s.lookahead = MIN_MATCH - 1;
                  fill_window(s);
                }
                s.strstart += s.lookahead;
                s.block_start = s.strstart;
                s.insert = s.lookahead;
                s.lookahead = 0;
                s.match_length = s.prev_length = MIN_MATCH - 1;
                s.match_available = 0;
                strm.next_in = next;
                strm.input = input;
                strm.avail_in = avail;
                s.wrap = wrap;
                return Z_OK;
              }
              exports3.deflateInit = deflateInit;
              exports3.deflateInit2 = deflateInit2;
              exports3.deflateReset = deflateReset;
              exports3.deflateResetKeep = deflateResetKeep;
              exports3.deflateSetHeader = deflateSetHeader;
              exports3.deflate = deflate;
              exports3.deflateEnd = deflateEnd;
              exports3.deflateSetDictionary = deflateSetDictionary;
              exports3.deflateInfo = "pako deflate (from Nodeca project)";
            },
            {
              "../utils/common": 32,
              "./adler32": 34,
              "./crc32": 36,
              "./messages": 42,
              "./trees": 43,
            },
          ],
          38: [
            function (_dereq_, module3, exports3) {
              "use strict";
              function GZheader() {
                this.text = 0;
                this.time = 0;
                this.xflags = 0;
                this.os = 0;
                this.extra = null;
                this.extra_len = 0;
                this.name = "";
                this.comment = "";
                this.hcrc = 0;
                this.done = false;
              }
              module3.exports = GZheader;
            },
            {},
          ],
          39: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var BAD = 30;
              var TYPE = 12;
              module3.exports = function inflate_fast(strm, start) {
                var state;
                var _in;
                var last;
                var _out;
                var beg;
                var end;
                var dmax;
                var wsize;
                var whave;
                var wnext;
                var s_window;
                var hold;
                var bits;
                var lcode;
                var dcode;
                var lmask;
                var dmask;
                var here;
                var op;
                var len;
                var dist;
                var from;
                var from_source;
                var input, output;
                state = strm.state;
                _in = strm.next_in;
                input = strm.input;
                last = _in + (strm.avail_in - 5);
                _out = strm.next_out;
                output = strm.output;
                beg = _out - (start - strm.avail_out);
                end = _out + (strm.avail_out - 257);
                dmax = state.dmax;
                wsize = state.wsize;
                whave = state.whave;
                wnext = state.wnext;
                s_window = state.window;
                hold = state.hold;
                bits = state.bits;
                lcode = state.lencode;
                dcode = state.distcode;
                lmask = (1 << state.lenbits) - 1;
                dmask = (1 << state.distbits) - 1;
                top: do {
                  if (bits < 15) {
                    hold += input[_in++] << bits;
                    bits += 8;
                    hold += input[_in++] << bits;
                    bits += 8;
                  }
                  here = lcode[hold & lmask];
                  dolen: for (;;) {
                    op = here >>> 24;
                    hold >>>= op;
                    bits -= op;
                    op = (here >>> 16) & 255;
                    if (op === 0) {
                      output[_out++] = here & 65535;
                    } else if (op & 16) {
                      len = here & 65535;
                      op &= 15;
                      if (op) {
                        if (bits < op) {
                          hold += input[_in++] << bits;
                          bits += 8;
                        }
                        len += hold & ((1 << op) - 1);
                        hold >>>= op;
                        bits -= op;
                      }
                      if (bits < 15) {
                        hold += input[_in++] << bits;
                        bits += 8;
                        hold += input[_in++] << bits;
                        bits += 8;
                      }
                      here = dcode[hold & dmask];
                      dodist: for (;;) {
                        op = here >>> 24;
                        hold >>>= op;
                        bits -= op;
                        op = (here >>> 16) & 255;
                        if (op & 16) {
                          dist = here & 65535;
                          op &= 15;
                          if (bits < op) {
                            hold += input[_in++] << bits;
                            bits += 8;
                            if (bits < op) {
                              hold += input[_in++] << bits;
                              bits += 8;
                            }
                          }
                          dist += hold & ((1 << op) - 1);
                          if (dist > dmax) {
                            strm.msg = "invalid distance too far back";
                            state.mode = BAD;
                            break top;
                          }
                          hold >>>= op;
                          bits -= op;
                          op = _out - beg;
                          if (dist > op) {
                            op = dist - op;
                            if (op > whave) {
                              if (state.sane) {
                                strm.msg = "invalid distance too far back";
                                state.mode = BAD;
                                break top;
                              }
                            }
                            from = 0;
                            from_source = s_window;
                            if (wnext === 0) {
                              from += wsize - op;
                              if (op < len) {
                                len -= op;
                                do {
                                  output[_out++] = s_window[from++];
                                } while (--op);
                                from = _out - dist;
                                from_source = output;
                              }
                            } else if (wnext < op) {
                              from += wsize + wnext - op;
                              op -= wnext;
                              if (op < len) {
                                len -= op;
                                do {
                                  output[_out++] = s_window[from++];
                                } while (--op);
                                from = 0;
                                if (wnext < len) {
                                  op = wnext;
                                  len -= op;
                                  do {
                                    output[_out++] = s_window[from++];
                                  } while (--op);
                                  from = _out - dist;
                                  from_source = output;
                                }
                              }
                            } else {
                              from += wnext - op;
                              if (op < len) {
                                len -= op;
                                do {
                                  output[_out++] = s_window[from++];
                                } while (--op);
                                from = _out - dist;
                                from_source = output;
                              }
                            }
                            while (len > 2) {
                              output[_out++] = from_source[from++];
                              output[_out++] = from_source[from++];
                              output[_out++] = from_source[from++];
                              len -= 3;
                            }
                            if (len) {
                              output[_out++] = from_source[from++];
                              if (len > 1) {
                                output[_out++] = from_source[from++];
                              }
                            }
                          } else {
                            from = _out - dist;
                            do {
                              output[_out++] = output[from++];
                              output[_out++] = output[from++];
                              output[_out++] = output[from++];
                              len -= 3;
                            } while (len > 2);
                            if (len) {
                              output[_out++] = output[from++];
                              if (len > 1) {
                                output[_out++] = output[from++];
                              }
                            }
                          }
                        } else if ((op & 64) === 0) {
                          here =
                            dcode[(here & 65535) + (hold & ((1 << op) - 1))];
                          continue dodist;
                        } else {
                          strm.msg = "invalid distance code";
                          state.mode = BAD;
                          break top;
                        }
                        break;
                      }
                    } else if ((op & 64) === 0) {
                      here = lcode[(here & 65535) + (hold & ((1 << op) - 1))];
                      continue dolen;
                    } else if (op & 32) {
                      state.mode = TYPE;
                      break top;
                    } else {
                      strm.msg = "invalid literal/length code";
                      state.mode = BAD;
                      break top;
                    }
                    break;
                  }
                } while (_in < last && _out < end);
                len = bits >> 3;
                _in -= len;
                bits -= len << 3;
                hold &= (1 << bits) - 1;
                strm.next_in = _in;
                strm.next_out = _out;
                strm.avail_in =
                  _in < last ? 5 + (last - _in) : 5 - (_in - last);
                strm.avail_out =
                  _out < end ? 257 + (end - _out) : 257 - (_out - end);
                state.hold = hold;
                state.bits = bits;
                return;
              };
            },
            {},
          ],
          40: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("../utils/common");
              var adler32 = _dereq_("./adler32");
              var crc32 = _dereq_("./crc32");
              var inflate_fast = _dereq_("./inffast");
              var inflate_table = _dereq_("./inftrees");
              var CODES = 0;
              var LENS = 1;
              var DISTS = 2;
              var Z_FINISH = 4;
              var Z_BLOCK = 5;
              var Z_TREES = 6;
              var Z_OK = 0;
              var Z_STREAM_END = 1;
              var Z_NEED_DICT = 2;
              var Z_STREAM_ERROR = -2;
              var Z_DATA_ERROR = -3;
              var Z_MEM_ERROR = -4;
              var Z_BUF_ERROR = -5;
              var Z_DEFLATED = 8;
              var HEAD = 1;
              var FLAGS = 2;
              var TIME = 3;
              var OS = 4;
              var EXLEN = 5;
              var EXTRA = 6;
              var NAME = 7;
              var COMMENT = 8;
              var HCRC = 9;
              var DICTID = 10;
              var DICT = 11;
              var TYPE = 12;
              var TYPEDO = 13;
              var STORED = 14;
              var COPY_ = 15;
              var COPY = 16;
              var TABLE = 17;
              var LENLENS = 18;
              var CODELENS = 19;
              var LEN_ = 20;
              var LEN = 21;
              var LENEXT = 22;
              var DIST = 23;
              var DISTEXT = 24;
              var MATCH = 25;
              var LIT = 26;
              var CHECK = 27;
              var LENGTH = 28;
              var DONE = 29;
              var BAD = 30;
              var MEM = 31;
              var SYNC = 32;
              var ENOUGH_LENS = 852;
              var ENOUGH_DISTS = 592;
              var MAX_WBITS = 15;
              var DEF_WBITS = MAX_WBITS;
              function zswap32(q) {
                return (
                  ((q >>> 24) & 255) +
                  ((q >>> 8) & 65280) +
                  ((q & 65280) << 8) +
                  ((q & 255) << 24)
                );
              }
              function InflateState() {
                this.mode = 0;
                this.last = false;
                this.wrap = 0;
                this.havedict = false;
                this.flags = 0;
                this.dmax = 0;
                this.check = 0;
                this.total = 0;
                this.head = null;
                this.wbits = 0;
                this.wsize = 0;
                this.whave = 0;
                this.wnext = 0;
                this.window = null;
                this.hold = 0;
                this.bits = 0;
                this.length = 0;
                this.offset = 0;
                this.extra = 0;
                this.lencode = null;
                this.distcode = null;
                this.lenbits = 0;
                this.distbits = 0;
                this.ncode = 0;
                this.nlen = 0;
                this.ndist = 0;
                this.have = 0;
                this.next = null;
                this.lens = new utils.Buf16(320);
                this.work = new utils.Buf16(288);
                this.lendyn = null;
                this.distdyn = null;
                this.sane = 0;
                this.back = 0;
                this.was = 0;
              }
              function inflateResetKeep(strm) {
                var state;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                strm.total_in = strm.total_out = state.total = 0;
                strm.msg = "";
                if (state.wrap) {
                  strm.adler = state.wrap & 1;
                }
                state.mode = HEAD;
                state.last = 0;
                state.havedict = 0;
                state.dmax = 32768;
                state.head = null;
                state.hold = 0;
                state.bits = 0;
                state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
                state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
                state.sane = 1;
                state.back = -1;
                return Z_OK;
              }
              function inflateReset(strm) {
                var state;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                state.wsize = 0;
                state.whave = 0;
                state.wnext = 0;
                return inflateResetKeep(strm);
              }
              function inflateReset2(strm, windowBits) {
                var wrap;
                var state;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                if (windowBits < 0) {
                  wrap = 0;
                  windowBits = -windowBits;
                } else {
                  wrap = (windowBits >> 4) + 1;
                  if (windowBits < 48) {
                    windowBits &= 15;
                  }
                }
                if (windowBits && (windowBits < 8 || windowBits > 15)) {
                  return Z_STREAM_ERROR;
                }
                if (state.window !== null && state.wbits !== windowBits) {
                  state.window = null;
                }
                state.wrap = wrap;
                state.wbits = windowBits;
                return inflateReset(strm);
              }
              function inflateInit2(strm, windowBits) {
                var ret;
                var state;
                if (!strm) {
                  return Z_STREAM_ERROR;
                }
                state = new InflateState();
                strm.state = state;
                state.window = null;
                ret = inflateReset2(strm, windowBits);
                if (ret !== Z_OK) {
                  strm.state = null;
                }
                return ret;
              }
              function inflateInit(strm) {
                return inflateInit2(strm, DEF_WBITS);
              }
              var virgin = true;
              var lenfix, distfix;
              function fixedtables(state) {
                if (virgin) {
                  var sym;
                  lenfix = new utils.Buf32(512);
                  distfix = new utils.Buf32(32);
                  sym = 0;
                  while (sym < 144) {
                    state.lens[sym++] = 8;
                  }
                  while (sym < 256) {
                    state.lens[sym++] = 9;
                  }
                  while (sym < 280) {
                    state.lens[sym++] = 7;
                  }
                  while (sym < 288) {
                    state.lens[sym++] = 8;
                  }
                  inflate_table(
                    LENS,
                    state.lens,
                    0,
                    288,
                    lenfix,
                    0,
                    state.work,
                    { bits: 9 }
                  );
                  sym = 0;
                  while (sym < 32) {
                    state.lens[sym++] = 5;
                  }
                  inflate_table(
                    DISTS,
                    state.lens,
                    0,
                    32,
                    distfix,
                    0,
                    state.work,
                    { bits: 5 }
                  );
                  virgin = false;
                }
                state.lencode = lenfix;
                state.lenbits = 9;
                state.distcode = distfix;
                state.distbits = 5;
              }
              function updatewindow(strm, src, end, copy) {
                var dist;
                var state = strm.state;
                if (state.window === null) {
                  state.wsize = 1 << state.wbits;
                  state.wnext = 0;
                  state.whave = 0;
                  state.window = new utils.Buf8(state.wsize);
                }
                if (copy >= state.wsize) {
                  utils.arraySet(
                    state.window,
                    src,
                    end - state.wsize,
                    state.wsize,
                    0
                  );
                  state.wnext = 0;
                  state.whave = state.wsize;
                } else {
                  dist = state.wsize - state.wnext;
                  if (dist > copy) {
                    dist = copy;
                  }
                  utils.arraySet(
                    state.window,
                    src,
                    end - copy,
                    dist,
                    state.wnext
                  );
                  copy -= dist;
                  if (copy) {
                    utils.arraySet(state.window, src, end - copy, copy, 0);
                    state.wnext = copy;
                    state.whave = state.wsize;
                  } else {
                    state.wnext += dist;
                    if (state.wnext === state.wsize) {
                      state.wnext = 0;
                    }
                    if (state.whave < state.wsize) {
                      state.whave += dist;
                    }
                  }
                }
                return 0;
              }
              function inflate(strm, flush) {
                var state;
                var input, output;
                var next;
                var put;
                var have, left;
                var hold;
                var bits;
                var _in, _out;
                var copy;
                var from;
                var from_source;
                var here = 0;
                var here_bits, here_op, here_val;
                var last_bits, last_op, last_val;
                var len;
                var ret;
                var hbuf = new utils.Buf8(4);
                var opts;
                var n;
                var order =
                  /* permutation of code lengths */
                  [
                    16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14,
                    1, 15,
                  ];
                if (
                  !strm ||
                  !strm.state ||
                  !strm.output ||
                  (!strm.input && strm.avail_in !== 0)
                ) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                if (state.mode === TYPE) {
                  state.mode = TYPEDO;
                }
                put = strm.next_out;
                output = strm.output;
                left = strm.avail_out;
                next = strm.next_in;
                input = strm.input;
                have = strm.avail_in;
                hold = state.hold;
                bits = state.bits;
                _in = have;
                _out = left;
                ret = Z_OK;
                inf_leave: for (;;) {
                  switch (state.mode) {
                    case HEAD:
                      if (state.wrap === 0) {
                        state.mode = TYPEDO;
                        break;
                      }
                      while (bits < 16) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if (state.wrap & 2 && hold === 35615) {
                        state.check = 0;
                        hbuf[0] = hold & 255;
                        hbuf[1] = (hold >>> 8) & 255;
                        state.check = crc32(state.check, hbuf, 2, 0);
                        hold = 0;
                        bits = 0;
                        state.mode = FLAGS;
                        break;
                      }
                      state.flags = 0;
                      if (state.head) {
                        state.head.done = false;
                      }
                      if (
                        !(state.wrap & 1) /* check if zlib header allowed */ ||
                        (((hold & 255) << 8) + (hold >> 8)) % 31
                      ) {
                        strm.msg = "incorrect header check";
                        state.mode = BAD;
                        break;
                      }
                      if ((hold & 15) !== Z_DEFLATED) {
                        strm.msg = "unknown compression method";
                        state.mode = BAD;
                        break;
                      }
                      hold >>>= 4;
                      bits -= 4;
                      len = (hold & 15) + 8;
                      if (state.wbits === 0) {
                        state.wbits = len;
                      } else if (len > state.wbits) {
                        strm.msg = "invalid window size";
                        state.mode = BAD;
                        break;
                      }
                      state.dmax = 1 << len;
                      strm.adler = state.check = 1;
                      state.mode = hold & 512 ? DICTID : TYPE;
                      hold = 0;
                      bits = 0;
                      break;
                    case FLAGS:
                      while (bits < 16) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      state.flags = hold;
                      if ((state.flags & 255) !== Z_DEFLATED) {
                        strm.msg = "unknown compression method";
                        state.mode = BAD;
                        break;
                      }
                      if (state.flags & 57344) {
                        strm.msg = "unknown header flags set";
                        state.mode = BAD;
                        break;
                      }
                      if (state.head) {
                        state.head.text = (hold >> 8) & 1;
                      }
                      if (state.flags & 512) {
                        hbuf[0] = hold & 255;
                        hbuf[1] = (hold >>> 8) & 255;
                        state.check = crc32(state.check, hbuf, 2, 0);
                      }
                      hold = 0;
                      bits = 0;
                      state.mode = TIME;
                    case TIME:
                      while (bits < 32) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if (state.head) {
                        state.head.time = hold;
                      }
                      if (state.flags & 512) {
                        hbuf[0] = hold & 255;
                        hbuf[1] = (hold >>> 8) & 255;
                        hbuf[2] = (hold >>> 16) & 255;
                        hbuf[3] = (hold >>> 24) & 255;
                        state.check = crc32(state.check, hbuf, 4, 0);
                      }
                      hold = 0;
                      bits = 0;
                      state.mode = OS;
                    case OS:
                      while (bits < 16) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if (state.head) {
                        state.head.xflags = hold & 255;
                        state.head.os = hold >> 8;
                      }
                      if (state.flags & 512) {
                        hbuf[0] = hold & 255;
                        hbuf[1] = (hold >>> 8) & 255;
                        state.check = crc32(state.check, hbuf, 2, 0);
                      }
                      hold = 0;
                      bits = 0;
                      state.mode = EXLEN;
                    case EXLEN:
                      if (state.flags & 1024) {
                        while (bits < 16) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        state.length = hold;
                        if (state.head) {
                          state.head.extra_len = hold;
                        }
                        if (state.flags & 512) {
                          hbuf[0] = hold & 255;
                          hbuf[1] = (hold >>> 8) & 255;
                          state.check = crc32(state.check, hbuf, 2, 0);
                        }
                        hold = 0;
                        bits = 0;
                      } else if (state.head) {
                        state.head.extra = null;
                      }
                      state.mode = EXTRA;
                    case EXTRA:
                      if (state.flags & 1024) {
                        copy = state.length;
                        if (copy > have) {
                          copy = have;
                        }
                        if (copy) {
                          if (state.head) {
                            len = state.head.extra_len - state.length;
                            if (!state.head.extra) {
                              state.head.extra = new Array(
                                state.head.extra_len
                              );
                            }
                            utils.arraySet(
                              state.head.extra,
                              input,
                              next,
                              // extra field is limited to 65536 bytes
                              // - no need for additional size check
                              copy,
                              /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                              len
                            );
                          }
                          if (state.flags & 512) {
                            state.check = crc32(state.check, input, copy, next);
                          }
                          have -= copy;
                          next += copy;
                          state.length -= copy;
                        }
                        if (state.length) {
                          break inf_leave;
                        }
                      }
                      state.length = 0;
                      state.mode = NAME;
                    case NAME:
                      if (state.flags & 2048) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        copy = 0;
                        do {
                          len = input[next + copy++];
                          if (state.head && len && state.length < 65536) {
                            state.head.name += String.fromCharCode(len);
                          }
                        } while (len && copy < have);
                        if (state.flags & 512) {
                          state.check = crc32(state.check, input, copy, next);
                        }
                        have -= copy;
                        next += copy;
                        if (len) {
                          break inf_leave;
                        }
                      } else if (state.head) {
                        state.head.name = null;
                      }
                      state.length = 0;
                      state.mode = COMMENT;
                    case COMMENT:
                      if (state.flags & 4096) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        copy = 0;
                        do {
                          len = input[next + copy++];
                          if (state.head && len && state.length < 65536) {
                            state.head.comment += String.fromCharCode(len);
                          }
                        } while (len && copy < have);
                        if (state.flags & 512) {
                          state.check = crc32(state.check, input, copy, next);
                        }
                        have -= copy;
                        next += copy;
                        if (len) {
                          break inf_leave;
                        }
                      } else if (state.head) {
                        state.head.comment = null;
                      }
                      state.mode = HCRC;
                    case HCRC:
                      if (state.flags & 512) {
                        while (bits < 16) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        if (hold !== (state.check & 65535)) {
                          strm.msg = "header crc mismatch";
                          state.mode = BAD;
                          break;
                        }
                        hold = 0;
                        bits = 0;
                      }
                      if (state.head) {
                        state.head.hcrc = (state.flags >> 9) & 1;
                        state.head.done = true;
                      }
                      strm.adler = state.check = 0;
                      state.mode = TYPE;
                      break;
                    case DICTID:
                      while (bits < 32) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      strm.adler = state.check = zswap32(hold);
                      hold = 0;
                      bits = 0;
                      state.mode = DICT;
                    case DICT:
                      if (state.havedict === 0) {
                        strm.next_out = put;
                        strm.avail_out = left;
                        strm.next_in = next;
                        strm.avail_in = have;
                        state.hold = hold;
                        state.bits = bits;
                        return Z_NEED_DICT;
                      }
                      strm.adler = state.check = 1;
                      state.mode = TYPE;
                    case TYPE:
                      if (flush === Z_BLOCK || flush === Z_TREES) {
                        break inf_leave;
                      }
                    case TYPEDO:
                      if (state.last) {
                        hold >>>= bits & 7;
                        bits -= bits & 7;
                        state.mode = CHECK;
                        break;
                      }
                      while (bits < 3) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      state.last = hold & 1;
                      hold >>>= 1;
                      bits -= 1;
                      switch (hold & 3) {
                        case 0:
                          state.mode = STORED;
                          break;
                        case 1:
                          fixedtables(state);
                          state.mode = LEN_;
                          if (flush === Z_TREES) {
                            hold >>>= 2;
                            bits -= 2;
                            break inf_leave;
                          }
                          break;
                        case 2:
                          state.mode = TABLE;
                          break;
                        case 3:
                          strm.msg = "invalid block type";
                          state.mode = BAD;
                      }
                      hold >>>= 2;
                      bits -= 2;
                      break;
                    case STORED:
                      hold >>>= bits & 7;
                      bits -= bits & 7;
                      while (bits < 32) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if ((hold & 65535) !== ((hold >>> 16) ^ 65535)) {
                        strm.msg = "invalid stored block lengths";
                        state.mode = BAD;
                        break;
                      }
                      state.length = hold & 65535;
                      hold = 0;
                      bits = 0;
                      state.mode = COPY_;
                      if (flush === Z_TREES) {
                        break inf_leave;
                      }
                    case COPY_:
                      state.mode = COPY;
                    case COPY:
                      copy = state.length;
                      if (copy) {
                        if (copy > have) {
                          copy = have;
                        }
                        if (copy > left) {
                          copy = left;
                        }
                        if (copy === 0) {
                          break inf_leave;
                        }
                        utils.arraySet(output, input, next, copy, put);
                        have -= copy;
                        next += copy;
                        left -= copy;
                        put += copy;
                        state.length -= copy;
                        break;
                      }
                      state.mode = TYPE;
                      break;
                    case TABLE:
                      while (bits < 14) {
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      state.nlen = (hold & 31) + 257;
                      hold >>>= 5;
                      bits -= 5;
                      state.ndist = (hold & 31) + 1;
                      hold >>>= 5;
                      bits -= 5;
                      state.ncode = (hold & 15) + 4;
                      hold >>>= 4;
                      bits -= 4;
                      if (state.nlen > 286 || state.ndist > 30) {
                        strm.msg = "too many length or distance symbols";
                        state.mode = BAD;
                        break;
                      }
                      state.have = 0;
                      state.mode = LENLENS;
                    case LENLENS:
                      while (state.have < state.ncode) {
                        while (bits < 3) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        state.lens[order[state.have++]] = hold & 7;
                        hold >>>= 3;
                        bits -= 3;
                      }
                      while (state.have < 19) {
                        state.lens[order[state.have++]] = 0;
                      }
                      state.lencode = state.lendyn;
                      state.lenbits = 7;
                      opts = { bits: state.lenbits };
                      ret = inflate_table(
                        CODES,
                        state.lens,
                        0,
                        19,
                        state.lencode,
                        0,
                        state.work,
                        opts
                      );
                      state.lenbits = opts.bits;
                      if (ret) {
                        strm.msg = "invalid code lengths set";
                        state.mode = BAD;
                        break;
                      }
                      state.have = 0;
                      state.mode = CODELENS;
                    case CODELENS:
                      while (state.have < state.nlen + state.ndist) {
                        for (;;) {
                          here =
                            state.lencode[hold & ((1 << state.lenbits) - 1)];
                          here_bits = here >>> 24;
                          here_op = (here >>> 16) & 255;
                          here_val = here & 65535;
                          if (here_bits <= bits) {
                            break;
                          }
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        if (here_val < 16) {
                          hold >>>= here_bits;
                          bits -= here_bits;
                          state.lens[state.have++] = here_val;
                        } else {
                          if (here_val === 16) {
                            n = here_bits + 2;
                            while (bits < n) {
                              if (have === 0) {
                                break inf_leave;
                              }
                              have--;
                              hold += input[next++] << bits;
                              bits += 8;
                            }
                            hold >>>= here_bits;
                            bits -= here_bits;
                            if (state.have === 0) {
                              strm.msg = "invalid bit length repeat";
                              state.mode = BAD;
                              break;
                            }
                            len = state.lens[state.have - 1];
                            copy = 3 + (hold & 3);
                            hold >>>= 2;
                            bits -= 2;
                          } else if (here_val === 17) {
                            n = here_bits + 3;
                            while (bits < n) {
                              if (have === 0) {
                                break inf_leave;
                              }
                              have--;
                              hold += input[next++] << bits;
                              bits += 8;
                            }
                            hold >>>= here_bits;
                            bits -= here_bits;
                            len = 0;
                            copy = 3 + (hold & 7);
                            hold >>>= 3;
                            bits -= 3;
                          } else {
                            n = here_bits + 7;
                            while (bits < n) {
                              if (have === 0) {
                                break inf_leave;
                              }
                              have--;
                              hold += input[next++] << bits;
                              bits += 8;
                            }
                            hold >>>= here_bits;
                            bits -= here_bits;
                            len = 0;
                            copy = 11 + (hold & 127);
                            hold >>>= 7;
                            bits -= 7;
                          }
                          if (state.have + copy > state.nlen + state.ndist) {
                            strm.msg = "invalid bit length repeat";
                            state.mode = BAD;
                            break;
                          }
                          while (copy--) {
                            state.lens[state.have++] = len;
                          }
                        }
                      }
                      if (state.mode === BAD) {
                        break;
                      }
                      if (state.lens[256] === 0) {
                        strm.msg = "invalid code -- missing end-of-block";
                        state.mode = BAD;
                        break;
                      }
                      state.lenbits = 9;
                      opts = { bits: state.lenbits };
                      ret = inflate_table(
                        LENS,
                        state.lens,
                        0,
                        state.nlen,
                        state.lencode,
                        0,
                        state.work,
                        opts
                      );
                      state.lenbits = opts.bits;
                      if (ret) {
                        strm.msg = "invalid literal/lengths set";
                        state.mode = BAD;
                        break;
                      }
                      state.distbits = 6;
                      state.distcode = state.distdyn;
                      opts = { bits: state.distbits };
                      ret = inflate_table(
                        DISTS,
                        state.lens,
                        state.nlen,
                        state.ndist,
                        state.distcode,
                        0,
                        state.work,
                        opts
                      );
                      state.distbits = opts.bits;
                      if (ret) {
                        strm.msg = "invalid distances set";
                        state.mode = BAD;
                        break;
                      }
                      state.mode = LEN_;
                      if (flush === Z_TREES) {
                        break inf_leave;
                      }
                    case LEN_:
                      state.mode = LEN;
                    case LEN:
                      if (have >= 6 && left >= 258) {
                        strm.next_out = put;
                        strm.avail_out = left;
                        strm.next_in = next;
                        strm.avail_in = have;
                        state.hold = hold;
                        state.bits = bits;
                        inflate_fast(strm, _out);
                        put = strm.next_out;
                        output = strm.output;
                        left = strm.avail_out;
                        next = strm.next_in;
                        input = strm.input;
                        have = strm.avail_in;
                        hold = state.hold;
                        bits = state.bits;
                        if (state.mode === TYPE) {
                          state.back = -1;
                        }
                        break;
                      }
                      state.back = 0;
                      for (;;) {
                        here = state.lencode[hold & ((1 << state.lenbits) - 1)];
                        here_bits = here >>> 24;
                        here_op = (here >>> 16) & 255;
                        here_val = here & 65535;
                        if (here_bits <= bits) {
                          break;
                        }
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if (here_op && (here_op & 240) === 0) {
                        last_bits = here_bits;
                        last_op = here_op;
                        last_val = here_val;
                        for (;;) {
                          here =
                            state.lencode[
                              last_val +
                                ((hold & ((1 << (last_bits + last_op)) - 1)) >>
                                  last_bits)
                            ];
                          here_bits = here >>> 24;
                          here_op = (here >>> 16) & 255;
                          here_val = here & 65535;
                          if (last_bits + here_bits <= bits) {
                            break;
                          }
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        hold >>>= last_bits;
                        bits -= last_bits;
                        state.back += last_bits;
                      }
                      hold >>>= here_bits;
                      bits -= here_bits;
                      state.back += here_bits;
                      state.length = here_val;
                      if (here_op === 0) {
                        state.mode = LIT;
                        break;
                      }
                      if (here_op & 32) {
                        state.back = -1;
                        state.mode = TYPE;
                        break;
                      }
                      if (here_op & 64) {
                        strm.msg = "invalid literal/length code";
                        state.mode = BAD;
                        break;
                      }
                      state.extra = here_op & 15;
                      state.mode = LENEXT;
                    case LENEXT:
                      if (state.extra) {
                        n = state.extra;
                        while (bits < n) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        state.length += hold & ((1 << state.extra) - 1);
                        hold >>>= state.extra;
                        bits -= state.extra;
                        state.back += state.extra;
                      }
                      state.was = state.length;
                      state.mode = DIST;
                    case DIST:
                      for (;;) {
                        here =
                          state.distcode[hold & ((1 << state.distbits) - 1)];
                        here_bits = here >>> 24;
                        here_op = (here >>> 16) & 255;
                        here_val = here & 65535;
                        if (here_bits <= bits) {
                          break;
                        }
                        if (have === 0) {
                          break inf_leave;
                        }
                        have--;
                        hold += input[next++] << bits;
                        bits += 8;
                      }
                      if ((here_op & 240) === 0) {
                        last_bits = here_bits;
                        last_op = here_op;
                        last_val = here_val;
                        for (;;) {
                          here =
                            state.distcode[
                              last_val +
                                ((hold & ((1 << (last_bits + last_op)) - 1)) >>
                                  last_bits)
                            ];
                          here_bits = here >>> 24;
                          here_op = (here >>> 16) & 255;
                          here_val = here & 65535;
                          if (last_bits + here_bits <= bits) {
                            break;
                          }
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        hold >>>= last_bits;
                        bits -= last_bits;
                        state.back += last_bits;
                      }
                      hold >>>= here_bits;
                      bits -= here_bits;
                      state.back += here_bits;
                      if (here_op & 64) {
                        strm.msg = "invalid distance code";
                        state.mode = BAD;
                        break;
                      }
                      state.offset = here_val;
                      state.extra = here_op & 15;
                      state.mode = DISTEXT;
                    case DISTEXT:
                      if (state.extra) {
                        n = state.extra;
                        while (bits < n) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        state.offset += hold & ((1 << state.extra) - 1);
                        hold >>>= state.extra;
                        bits -= state.extra;
                        state.back += state.extra;
                      }
                      if (state.offset > state.dmax) {
                        strm.msg = "invalid distance too far back";
                        state.mode = BAD;
                        break;
                      }
                      state.mode = MATCH;
                    case MATCH:
                      if (left === 0) {
                        break inf_leave;
                      }
                      copy = _out - left;
                      if (state.offset > copy) {
                        copy = state.offset - copy;
                        if (copy > state.whave) {
                          if (state.sane) {
                            strm.msg = "invalid distance too far back";
                            state.mode = BAD;
                            break;
                          }
                        }
                        if (copy > state.wnext) {
                          copy -= state.wnext;
                          from = state.wsize - copy;
                        } else {
                          from = state.wnext - copy;
                        }
                        if (copy > state.length) {
                          copy = state.length;
                        }
                        from_source = state.window;
                      } else {
                        from_source = output;
                        from = put - state.offset;
                        copy = state.length;
                      }
                      if (copy > left) {
                        copy = left;
                      }
                      left -= copy;
                      state.length -= copy;
                      do {
                        output[put++] = from_source[from++];
                      } while (--copy);
                      if (state.length === 0) {
                        state.mode = LEN;
                      }
                      break;
                    case LIT:
                      if (left === 0) {
                        break inf_leave;
                      }
                      output[put++] = state.length;
                      left--;
                      state.mode = LEN;
                      break;
                    case CHECK:
                      if (state.wrap) {
                        while (bits < 32) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold |= input[next++] << bits;
                          bits += 8;
                        }
                        _out -= left;
                        strm.total_out += _out;
                        state.total += _out;
                        if (_out) {
                          strm.adler = state.check =
                            /*UPDATE(state.check, put - _out, _out);*/
                            state.flags
                              ? crc32(state.check, output, _out, put - _out)
                              : adler32(state.check, output, _out, put - _out);
                        }
                        _out = left;
                        if (
                          (state.flags ? hold : zswap32(hold)) !== state.check
                        ) {
                          strm.msg = "incorrect data check";
                          state.mode = BAD;
                          break;
                        }
                        hold = 0;
                        bits = 0;
                      }
                      state.mode = LENGTH;
                    case LENGTH:
                      if (state.wrap && state.flags) {
                        while (bits < 32) {
                          if (have === 0) {
                            break inf_leave;
                          }
                          have--;
                          hold += input[next++] << bits;
                          bits += 8;
                        }
                        if (hold !== (state.total & 4294967295)) {
                          strm.msg = "incorrect length check";
                          state.mode = BAD;
                          break;
                        }
                        hold = 0;
                        bits = 0;
                      }
                      state.mode = DONE;
                    case DONE:
                      ret = Z_STREAM_END;
                      break inf_leave;
                    case BAD:
                      ret = Z_DATA_ERROR;
                      break inf_leave;
                    case MEM:
                      return Z_MEM_ERROR;
                    case SYNC:
                    default:
                      return Z_STREAM_ERROR;
                  }
                }
                strm.next_out = put;
                strm.avail_out = left;
                strm.next_in = next;
                strm.avail_in = have;
                state.hold = hold;
                state.bits = bits;
                if (
                  state.wsize ||
                  (_out !== strm.avail_out &&
                    state.mode < BAD &&
                    (state.mode < CHECK || flush !== Z_FINISH))
                ) {
                  if (
                    updatewindow(
                      strm,
                      strm.output,
                      strm.next_out,
                      _out - strm.avail_out
                    )
                  ) {
                    state.mode = MEM;
                    return Z_MEM_ERROR;
                  }
                }
                _in -= strm.avail_in;
                _out -= strm.avail_out;
                strm.total_in += _in;
                strm.total_out += _out;
                state.total += _out;
                if (state.wrap && _out) {
                  strm.adler = state.check =
                    /*UPDATE(state.check, strm.next_out - _out, _out);*/
                    state.flags
                      ? crc32(state.check, output, _out, strm.next_out - _out)
                      : adler32(
                          state.check,
                          output,
                          _out,
                          strm.next_out - _out
                        );
                }
                strm.data_type =
                  state.bits +
                  (state.last ? 64 : 0) +
                  (state.mode === TYPE ? 128 : 0) +
                  (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
                if (
                  ((_in === 0 && _out === 0) || flush === Z_FINISH) &&
                  ret === Z_OK
                ) {
                  ret = Z_BUF_ERROR;
                }
                return ret;
              }
              function inflateEnd(strm) {
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                var state = strm.state;
                if (state.window) {
                  state.window = null;
                }
                strm.state = null;
                return Z_OK;
              }
              function inflateGetHeader(strm, head) {
                var state;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                if ((state.wrap & 2) === 0) {
                  return Z_STREAM_ERROR;
                }
                state.head = head;
                head.done = false;
                return Z_OK;
              }
              function inflateSetDictionary(strm, dictionary) {
                var dictLength = dictionary.length;
                var state;
                var dictid;
                var ret;
                if (!strm || !strm.state) {
                  return Z_STREAM_ERROR;
                }
                state = strm.state;
                if (state.wrap !== 0 && state.mode !== DICT) {
                  return Z_STREAM_ERROR;
                }
                if (state.mode === DICT) {
                  dictid = 1;
                  dictid = adler32(dictid, dictionary, dictLength, 0);
                  if (dictid !== state.check) {
                    return Z_DATA_ERROR;
                  }
                }
                ret = updatewindow(strm, dictionary, dictLength, dictLength);
                if (ret) {
                  state.mode = MEM;
                  return Z_MEM_ERROR;
                }
                state.havedict = 1;
                return Z_OK;
              }
              exports3.inflateReset = inflateReset;
              exports3.inflateReset2 = inflateReset2;
              exports3.inflateResetKeep = inflateResetKeep;
              exports3.inflateInit = inflateInit;
              exports3.inflateInit2 = inflateInit2;
              exports3.inflate = inflate;
              exports3.inflateEnd = inflateEnd;
              exports3.inflateGetHeader = inflateGetHeader;
              exports3.inflateSetDictionary = inflateSetDictionary;
              exports3.inflateInfo = "pako inflate (from Nodeca project)";
            },
            {
              "../utils/common": 32,
              "./adler32": 34,
              "./crc32": 36,
              "./inffast": 39,
              "./inftrees": 41,
            },
          ],
          41: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("../utils/common");
              var MAXBITS = 15;
              var ENOUGH_LENS = 852;
              var ENOUGH_DISTS = 592;
              var CODES = 0;
              var LENS = 1;
              var DISTS = 2;
              var lbase = [
                /* Length codes 257..285 base */
                3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43,
                51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0,
              ];
              var lext = [
                /* Length codes 257..285 extra */
                16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
                19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78,
              ];
              var dbase = [
                /* Distance codes 0..29 base */
                1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257,
                385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289,
                16385, 24577, 0, 0,
              ];
              var dext = [
                /* Distance codes 0..29 extra */
                16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
                23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64,
              ];
              module3.exports = function inflate_table(
                type,
                lens,
                lens_index,
                codes,
                table,
                table_index,
                work,
                opts
              ) {
                var bits = opts.bits;
                var len = 0;
                var sym = 0;
                var min = 0,
                  max = 0;
                var root = 0;
                var curr = 0;
                var drop = 0;
                var left = 0;
                var used = 0;
                var huff = 0;
                var incr;
                var fill;
                var low;
                var mask;
                var next;
                var base = null;
                var base_index = 0;
                var end;
                var count = new utils.Buf16(MAXBITS + 1);
                var offs = new utils.Buf16(MAXBITS + 1);
                var extra = null;
                var extra_index = 0;
                var here_bits, here_op, here_val;
                for (len = 0; len <= MAXBITS; len++) {
                  count[len] = 0;
                }
                for (sym = 0; sym < codes; sym++) {
                  count[lens[lens_index + sym]]++;
                }
                root = bits;
                for (max = MAXBITS; max >= 1; max--) {
                  if (count[max] !== 0) {
                    break;
                  }
                }
                if (root > max) {
                  root = max;
                }
                if (max === 0) {
                  table[table_index++] = (1 << 24) | (64 << 16) | 0;
                  table[table_index++] = (1 << 24) | (64 << 16) | 0;
                  opts.bits = 1;
                  return 0;
                }
                for (min = 1; min < max; min++) {
                  if (count[min] !== 0) {
                    break;
                  }
                }
                if (root < min) {
                  root = min;
                }
                left = 1;
                for (len = 1; len <= MAXBITS; len++) {
                  left <<= 1;
                  left -= count[len];
                  if (left < 0) {
                    return -1;
                  }
                }
                if (left > 0 && (type === CODES || max !== 1)) {
                  return -1;
                }
                offs[1] = 0;
                for (len = 1; len < MAXBITS; len++) {
                  offs[len + 1] = offs[len] + count[len];
                }
                for (sym = 0; sym < codes; sym++) {
                  if (lens[lens_index + sym] !== 0) {
                    work[offs[lens[lens_index + sym]]++] = sym;
                  }
                }
                if (type === CODES) {
                  base = extra = work;
                  end = 19;
                } else if (type === LENS) {
                  base = lbase;
                  base_index -= 257;
                  extra = lext;
                  extra_index -= 257;
                  end = 256;
                } else {
                  base = dbase;
                  extra = dext;
                  end = -1;
                }
                huff = 0;
                sym = 0;
                len = min;
                next = table_index;
                curr = root;
                drop = 0;
                low = -1;
                used = 1 << root;
                mask = used - 1;
                if (
                  (type === LENS && used > ENOUGH_LENS) ||
                  (type === DISTS && used > ENOUGH_DISTS)
                ) {
                  return 1;
                }
                var i = 0;
                for (;;) {
                  i++;
                  here_bits = len - drop;
                  if (work[sym] < end) {
                    here_op = 0;
                    here_val = work[sym];
                  } else if (work[sym] > end) {
                    here_op = extra[extra_index + work[sym]];
                    here_val = base[base_index + work[sym]];
                  } else {
                    here_op = 32 + 64;
                    here_val = 0;
                  }
                  incr = 1 << (len - drop);
                  fill = 1 << curr;
                  min = fill;
                  do {
                    fill -= incr;
                    table[next + (huff >> drop) + fill] =
                      (here_bits << 24) | (here_op << 16) | here_val | 0;
                  } while (fill !== 0);
                  incr = 1 << (len - 1);
                  while (huff & incr) {
                    incr >>= 1;
                  }
                  if (incr !== 0) {
                    huff &= incr - 1;
                    huff += incr;
                  } else {
                    huff = 0;
                  }
                  sym++;
                  if (--count[len] === 0) {
                    if (len === max) {
                      break;
                    }
                    len = lens[lens_index + work[sym]];
                  }
                  if (len > root && (huff & mask) !== low) {
                    if (drop === 0) {
                      drop = root;
                    }
                    next += min;
                    curr = len - drop;
                    left = 1 << curr;
                    while (curr + drop < max) {
                      left -= count[curr + drop];
                      if (left <= 0) {
                        break;
                      }
                      curr++;
                      left <<= 1;
                    }
                    used += 1 << curr;
                    if (
                      (type === LENS && used > ENOUGH_LENS) ||
                      (type === DISTS && used > ENOUGH_DISTS)
                    ) {
                      return 1;
                    }
                    low = huff & mask;
                    table[low] =
                      (root << 24) | (curr << 16) | (next - table_index) | 0;
                  }
                }
                if (huff !== 0) {
                  table[next + huff] = ((len - drop) << 24) | (64 << 16) | 0;
                }
                opts.bits = root;
                return 0;
              };
            },
            { "../utils/common": 32 },
          ],
          42: [
            function (_dereq_, module3, exports3) {
              "use strict";
              module3.exports = {
                2: "need dictionary",
                /* Z_NEED_DICT       2  */
                1: "stream end",
                /* Z_STREAM_END      1  */
                0: "",
                /* Z_OK              0  */
                "-1": "file error",
                /* Z_ERRNO         (-1) */
                "-2": "stream error",
                /* Z_STREAM_ERROR  (-2) */
                "-3": "data error",
                /* Z_DATA_ERROR    (-3) */
                "-4": "insufficient memory",
                /* Z_MEM_ERROR     (-4) */
                "-5": "buffer error",
                /* Z_BUF_ERROR     (-5) */
                "-6": "incompatible version",
                /* Z_VERSION_ERROR (-6) */
              };
            },
            {},
          ],
          43: [
            function (_dereq_, module3, exports3) {
              "use strict";
              var utils = _dereq_("../utils/common");
              var Z_FIXED = 4;
              var Z_BINARY = 0;
              var Z_TEXT = 1;
              var Z_UNKNOWN = 2;
              function zero(buf) {
                var len = buf.length;
                while (--len >= 0) {
                  buf[len] = 0;
                }
              }
              var STORED_BLOCK = 0;
              var STATIC_TREES = 1;
              var DYN_TREES = 2;
              var MIN_MATCH = 3;
              var MAX_MATCH = 258;
              var LENGTH_CODES = 29;
              var LITERALS = 256;
              var L_CODES = LITERALS + 1 + LENGTH_CODES;
              var D_CODES = 30;
              var BL_CODES = 19;
              var HEAP_SIZE = 2 * L_CODES + 1;
              var MAX_BITS = 15;
              var Buf_size = 16;
              var MAX_BL_BITS = 7;
              var END_BLOCK = 256;
              var REP_3_6 = 16;
              var REPZ_3_10 = 17;
              var REPZ_11_138 = 18;
              var extra_lbits =
                /* extra bits for each length code */
                [
                  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4,
                  4, 4, 4, 5, 5, 5, 5, 0,
                ];
              var extra_dbits =
                /* extra bits for each distance code */
                [
                  0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9,
                  9, 10, 10, 11, 11, 12, 12, 13, 13,
                ];
              var extra_blbits =
                /* extra bits for each bit length code */
                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
              var bl_order = [
                16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1,
                15,
              ];
              var DIST_CODE_LEN = 512;
              var static_ltree = new Array((L_CODES + 2) * 2);
              zero(static_ltree);
              var static_dtree = new Array(D_CODES * 2);
              zero(static_dtree);
              var _dist_code = new Array(DIST_CODE_LEN);
              zero(_dist_code);
              var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
              zero(_length_code);
              var base_length = new Array(LENGTH_CODES);
              zero(base_length);
              var base_dist = new Array(D_CODES);
              zero(base_dist);
              function StaticTreeDesc(
                static_tree,
                extra_bits,
                extra_base,
                elems,
                max_length
              ) {
                this.static_tree = static_tree;
                this.extra_bits = extra_bits;
                this.extra_base = extra_base;
                this.elems = elems;
                this.max_length = max_length;
                this.has_stree = static_tree && static_tree.length;
              }
              var static_l_desc;
              var static_d_desc;
              var static_bl_desc;
              function TreeDesc(dyn_tree, stat_desc) {
                this.dyn_tree = dyn_tree;
                this.max_code = 0;
                this.stat_desc = stat_desc;
              }
              function d_code(dist) {
                return dist < 256
                  ? _dist_code[dist]
                  : _dist_code[256 + (dist >>> 7)];
              }
              function put_short(s, w) {
                s.pending_buf[s.pending++] = w & 255;
                s.pending_buf[s.pending++] = (w >>> 8) & 255;
              }
              function send_bits(s, value, length) {
                if (s.bi_valid > Buf_size - length) {
                  s.bi_buf |= (value << s.bi_valid) & 65535;
                  put_short(s, s.bi_buf);
                  s.bi_buf = value >> (Buf_size - s.bi_valid);
                  s.bi_valid += length - Buf_size;
                } else {
                  s.bi_buf |= (value << s.bi_valid) & 65535;
                  s.bi_valid += length;
                }
              }
              function send_code(s, c, tree) {
                send_bits(
                  s,
                  tree[c * 2],
                  tree[c * 2 + 1]
                  /*.Len*/
                );
              }
              function bi_reverse(code, len) {
                var res = 0;
                do {
                  res |= code & 1;
                  code >>>= 1;
                  res <<= 1;
                } while (--len > 0);
                return res >>> 1;
              }
              function bi_flush(s) {
                if (s.bi_valid === 16) {
                  put_short(s, s.bi_buf);
                  s.bi_buf = 0;
                  s.bi_valid = 0;
                } else if (s.bi_valid >= 8) {
                  s.pending_buf[s.pending++] = s.bi_buf & 255;
                  s.bi_buf >>= 8;
                  s.bi_valid -= 8;
                }
              }
              function gen_bitlen(s, desc) {
                var tree = desc.dyn_tree;
                var max_code = desc.max_code;
                var stree = desc.stat_desc.static_tree;
                var has_stree = desc.stat_desc.has_stree;
                var extra = desc.stat_desc.extra_bits;
                var base = desc.stat_desc.extra_base;
                var max_length = desc.stat_desc.max_length;
                var h;
                var n, m;
                var bits;
                var xbits;
                var f;
                var overflow = 0;
                for (bits = 0; bits <= MAX_BITS; bits++) {
                  s.bl_count[bits] = 0;
                }
                tree[s.heap[s.heap_max] * 2 + 1] = 0;
                for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
                  n = s.heap[h];
                  bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
                  if (bits > max_length) {
                    bits = max_length;
                    overflow++;
                  }
                  tree[n * 2 + 1] = bits;
                  if (n > max_code) {
                    continue;
                  }
                  s.bl_count[bits]++;
                  xbits = 0;
                  if (n >= base) {
                    xbits = extra[n - base];
                  }
                  f = tree[n * 2];
                  s.opt_len += f * (bits + xbits);
                  if (has_stree) {
                    s.static_len += f * (stree[n * 2 + 1] + xbits);
                  }
                }
                if (overflow === 0) {
                  return;
                }
                do {
                  bits = max_length - 1;
                  while (s.bl_count[bits] === 0) {
                    bits--;
                  }
                  s.bl_count[bits]--;
                  s.bl_count[bits + 1] += 2;
                  s.bl_count[max_length]--;
                  overflow -= 2;
                } while (overflow > 0);
                for (bits = max_length; bits !== 0; bits--) {
                  n = s.bl_count[bits];
                  while (n !== 0) {
                    m = s.heap[--h];
                    if (m > max_code) {
                      continue;
                    }
                    if (tree[m * 2 + 1] !== bits) {
                      s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
                      tree[m * 2 + 1] = bits;
                    }
                    n--;
                  }
                }
              }
              function gen_codes(tree, max_code, bl_count) {
                var next_code = new Array(MAX_BITS + 1);
                var code = 0;
                var bits;
                var n;
                for (bits = 1; bits <= MAX_BITS; bits++) {
                  next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
                }
                for (n = 0; n <= max_code; n++) {
                  var len = tree[n * 2 + 1];
                  if (len === 0) {
                    continue;
                  }
                  tree[n * 2] = bi_reverse(next_code[len]++, len);
                }
              }
              function tr_static_init() {
                var n;
                var bits;
                var length;
                var code;
                var dist;
                var bl_count = new Array(MAX_BITS + 1);
                length = 0;
                for (code = 0; code < LENGTH_CODES - 1; code++) {
                  base_length[code] = length;
                  for (n = 0; n < 1 << extra_lbits[code]; n++) {
                    _length_code[length++] = code;
                  }
                }
                _length_code[length - 1] = code;
                dist = 0;
                for (code = 0; code < 16; code++) {
                  base_dist[code] = dist;
                  for (n = 0; n < 1 << extra_dbits[code]; n++) {
                    _dist_code[dist++] = code;
                  }
                }
                dist >>= 7;
                for (; code < D_CODES; code++) {
                  base_dist[code] = dist << 7;
                  for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {
                    _dist_code[256 + dist++] = code;
                  }
                }
                for (bits = 0; bits <= MAX_BITS; bits++) {
                  bl_count[bits] = 0;
                }
                n = 0;
                while (n <= 143) {
                  static_ltree[n * 2 + 1] = 8;
                  n++;
                  bl_count[8]++;
                }
                while (n <= 255) {
                  static_ltree[n * 2 + 1] = 9;
                  n++;
                  bl_count[9]++;
                }
                while (n <= 279) {
                  static_ltree[n * 2 + 1] = 7;
                  n++;
                  bl_count[7]++;
                }
                while (n <= 287) {
                  static_ltree[n * 2 + 1] = 8;
                  n++;
                  bl_count[8]++;
                }
                gen_codes(static_ltree, L_CODES + 1, bl_count);
                for (n = 0; n < D_CODES; n++) {
                  static_dtree[n * 2 + 1] = 5;
                  static_dtree[n * 2] = bi_reverse(n, 5);
                }
                static_l_desc = new StaticTreeDesc(
                  static_ltree,
                  extra_lbits,
                  LITERALS + 1,
                  L_CODES,
                  MAX_BITS
                );
                static_d_desc = new StaticTreeDesc(
                  static_dtree,
                  extra_dbits,
                  0,
                  D_CODES,
                  MAX_BITS
                );
                static_bl_desc = new StaticTreeDesc(
                  new Array(0),
                  extra_blbits,
                  0,
                  BL_CODES,
                  MAX_BL_BITS
                );
              }
              function init_block(s) {
                var n;
                for (n = 0; n < L_CODES; n++) {
                  s.dyn_ltree[n * 2] = 0;
                }
                for (n = 0; n < D_CODES; n++) {
                  s.dyn_dtree[n * 2] = 0;
                }
                for (n = 0; n < BL_CODES; n++) {
                  s.bl_tree[n * 2] = 0;
                }
                s.dyn_ltree[END_BLOCK * 2] = 1;
                s.opt_len = s.static_len = 0;
                s.last_lit = s.matches = 0;
              }
              function bi_windup(s) {
                if (s.bi_valid > 8) {
                  put_short(s, s.bi_buf);
                } else if (s.bi_valid > 0) {
                  s.pending_buf[s.pending++] = s.bi_buf;
                }
                s.bi_buf = 0;
                s.bi_valid = 0;
              }
              function copy_block(s, buf, len, header) {
                bi_windup(s);
                if (header) {
                  put_short(s, len);
                  put_short(s, ~len);
                }
                utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
                s.pending += len;
              }
              function smaller(tree, n, m, depth) {
                var _n2 = n * 2;
                var _m2 = m * 2;
                return (
                  tree[_n2] < tree[_m2] ||
                  (tree[_n2] === tree[_m2] && depth[n] <= depth[m])
                );
              }
              function pqdownheap(s, tree, k) {
                var v = s.heap[k];
                var j = k << 1;
                while (j <= s.heap_len) {
                  if (
                    j < s.heap_len &&
                    smaller(tree, s.heap[j + 1], s.heap[j], s.depth)
                  ) {
                    j++;
                  }
                  if (smaller(tree, v, s.heap[j], s.depth)) {
                    break;
                  }
                  s.heap[k] = s.heap[j];
                  k = j;
                  j <<= 1;
                }
                s.heap[k] = v;
              }
              function compress_block(s, ltree, dtree) {
                var dist;
                var lc;
                var lx = 0;
                var code;
                var extra;
                if (s.last_lit !== 0) {
                  do {
                    dist =
                      (s.pending_buf[s.d_buf + lx * 2] << 8) |
                      s.pending_buf[s.d_buf + lx * 2 + 1];
                    lc = s.pending_buf[s.l_buf + lx];
                    lx++;
                    if (dist === 0) {
                      send_code(s, lc, ltree);
                    } else {
                      code = _length_code[lc];
                      send_code(s, code + LITERALS + 1, ltree);
                      extra = extra_lbits[code];
                      if (extra !== 0) {
                        lc -= base_length[code];
                        send_bits(s, lc, extra);
                      }
                      dist--;
                      code = d_code(dist);
                      send_code(s, code, dtree);
                      extra = extra_dbits[code];
                      if (extra !== 0) {
                        dist -= base_dist[code];
                        send_bits(s, dist, extra);
                      }
                    }
                  } while (lx < s.last_lit);
                }
                send_code(s, END_BLOCK, ltree);
              }
              function build_tree(s, desc) {
                var tree = desc.dyn_tree;
                var stree = desc.stat_desc.static_tree;
                var has_stree = desc.stat_desc.has_stree;
                var elems = desc.stat_desc.elems;
                var n, m;
                var max_code = -1;
                var node;
                s.heap_len = 0;
                s.heap_max = HEAP_SIZE;
                for (n = 0; n < elems; n++) {
                  if (tree[n * 2] !== 0) {
                    s.heap[++s.heap_len] = max_code = n;
                    s.depth[n] = 0;
                  } else {
                    tree[n * 2 + 1] = 0;
                  }
                }
                while (s.heap_len < 2) {
                  node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
                  tree[node * 2] = 1;
                  s.depth[node] = 0;
                  s.opt_len--;
                  if (has_stree) {
                    s.static_len -= stree[node * 2 + 1];
                  }
                }
                desc.max_code = max_code;
                for (n = s.heap_len >> 1; n >= 1; n--) {
                  pqdownheap(s, tree, n);
                }
                node = elems;
                do {
                  n = s.heap[1];
                  /*SMALLEST*/
                  s.heap[1] = s.heap[s.heap_len--];
                  /*SMALLEST*/
                  pqdownheap(
                    s,
                    tree,
                    1
                    /*SMALLEST*/
                  );
                  m = s.heap[1];
                  /*SMALLEST*/
                  s.heap[--s.heap_max] = n;
                  s.heap[--s.heap_max] = m;
                  tree[node * 2] = tree[n * 2] + tree[m * 2];
                  s.depth[node] =
                    (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
                  tree[n * 2 + 1] = tree[m * 2 + 1] = node;
                  s.heap[1] =
                    /*SMALLEST*/
                    node++;
                  pqdownheap(
                    s,
                    tree,
                    1
                    /*SMALLEST*/
                  );
                } while (s.heap_len >= 2);
                s.heap[--s.heap_max] = s.heap[1];
                /*SMALLEST*/
                gen_bitlen(s, desc);
                gen_codes(tree, max_code, s.bl_count);
              }
              function scan_tree(s, tree, max_code) {
                var n;
                var prevlen = -1;
                var curlen;
                var nextlen = tree[0 * 2 + 1];
                var count = 0;
                var max_count = 7;
                var min_count = 4;
                if (nextlen === 0) {
                  max_count = 138;
                  min_count = 3;
                }
                tree[(max_code + 1) * 2 + 1] = 65535;
                for (n = 0; n <= max_code; n++) {
                  curlen = nextlen;
                  nextlen = tree[(n + 1) * 2 + 1];
                  if (++count < max_count && curlen === nextlen) {
                    continue;
                  } else if (count < min_count) {
                    s.bl_tree[curlen * 2] += count;
                  } else if (curlen !== 0) {
                    if (curlen !== prevlen) {
                      s.bl_tree[curlen * 2]++;
                    }
                    s.bl_tree[REP_3_6 * 2]++;
                  } else if (count <= 10) {
                    s.bl_tree[REPZ_3_10 * 2]++;
                  } else {
                    s.bl_tree[REPZ_11_138 * 2]++;
                  }
                  count = 0;
                  prevlen = curlen;
                  if (nextlen === 0) {
                    max_count = 138;
                    min_count = 3;
                  } else if (curlen === nextlen) {
                    max_count = 6;
                    min_count = 3;
                  } else {
                    max_count = 7;
                    min_count = 4;
                  }
                }
              }
              function send_tree(s, tree, max_code) {
                var n;
                var prevlen = -1;
                var curlen;
                var nextlen = tree[0 * 2 + 1];
                var count = 0;
                var max_count = 7;
                var min_count = 4;
                if (nextlen === 0) {
                  max_count = 138;
                  min_count = 3;
                }
                for (n = 0; n <= max_code; n++) {
                  curlen = nextlen;
                  nextlen = tree[(n + 1) * 2 + 1];
                  if (++count < max_count && curlen === nextlen) {
                    continue;
                  } else if (count < min_count) {
                    do {
                      send_code(s, curlen, s.bl_tree);
                    } while (--count !== 0);
                  } else if (curlen !== 0) {
                    if (curlen !== prevlen) {
                      send_code(s, curlen, s.bl_tree);
                      count--;
                    }
                    send_code(s, REP_3_6, s.bl_tree);
                    send_bits(s, count - 3, 2);
                  } else if (count <= 10) {
                    send_code(s, REPZ_3_10, s.bl_tree);
                    send_bits(s, count - 3, 3);
                  } else {
                    send_code(s, REPZ_11_138, s.bl_tree);
                    send_bits(s, count - 11, 7);
                  }
                  count = 0;
                  prevlen = curlen;
                  if (nextlen === 0) {
                    max_count = 138;
                    min_count = 3;
                  } else if (curlen === nextlen) {
                    max_count = 6;
                    min_count = 3;
                  } else {
                    max_count = 7;
                    min_count = 4;
                  }
                }
              }
              function build_bl_tree(s) {
                var max_blindex;
                scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
                scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
                build_tree(s, s.bl_desc);
                for (
                  max_blindex = BL_CODES - 1;
                  max_blindex >= 3;
                  max_blindex--
                ) {
                  if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
                    break;
                  }
                }
                s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
                return max_blindex;
              }
              function send_all_trees(s, lcodes, dcodes, blcodes) {
                var rank;
                send_bits(s, lcodes - 257, 5);
                send_bits(s, dcodes - 1, 5);
                send_bits(s, blcodes - 4, 4);
                for (rank = 0; rank < blcodes; rank++) {
                  send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);
                }
                send_tree(s, s.dyn_ltree, lcodes - 1);
                send_tree(s, s.dyn_dtree, dcodes - 1);
              }
              function detect_data_type(s) {
                var black_mask = 4093624447;
                var n;
                for (n = 0; n <= 31; n++, black_mask >>>= 1) {
                  if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) {
                    return Z_BINARY;
                  }
                }
                if (
                  s.dyn_ltree[9 * 2] !== 0 ||
                  s.dyn_ltree[10 * 2] !== 0 ||
                  s.dyn_ltree[13 * 2] !== 0
                ) {
                  return Z_TEXT;
                }
                for (n = 32; n < LITERALS; n++) {
                  if (s.dyn_ltree[n * 2] !== 0) {
                    return Z_TEXT;
                  }
                }
                return Z_BINARY;
              }
              var static_init_done = false;
              function _tr_init(s) {
                if (!static_init_done) {
                  tr_static_init();
                  static_init_done = true;
                }
                s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
                s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
                s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
                s.bi_buf = 0;
                s.bi_valid = 0;
                init_block(s);
              }
              function _tr_stored_block(s, buf, stored_len, last) {
                send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
                copy_block(s, buf, stored_len, true);
              }
              function _tr_align(s) {
                send_bits(s, STATIC_TREES << 1, 3);
                send_code(s, END_BLOCK, static_ltree);
                bi_flush(s);
              }
              function _tr_flush_block(s, buf, stored_len, last) {
                var opt_lenb, static_lenb;
                var max_blindex = 0;
                if (s.level > 0) {
                  if (s.strm.data_type === Z_UNKNOWN) {
                    s.strm.data_type = detect_data_type(s);
                  }
                  build_tree(s, s.l_desc);
                  build_tree(s, s.d_desc);
                  max_blindex = build_bl_tree(s);
                  opt_lenb = (s.opt_len + 3 + 7) >>> 3;
                  static_lenb = (s.static_len + 3 + 7) >>> 3;
                  if (static_lenb <= opt_lenb) {
                    opt_lenb = static_lenb;
                  }
                } else {
                  opt_lenb = static_lenb = stored_len + 5;
                }
                if (stored_len + 4 <= opt_lenb && buf !== -1) {
                  _tr_stored_block(s, buf, stored_len, last);
                } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
                  send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
                  compress_block(s, static_ltree, static_dtree);
                } else {
                  send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
                  send_all_trees(
                    s,
                    s.l_desc.max_code + 1,
                    s.d_desc.max_code + 1,
                    max_blindex + 1
                  );
                  compress_block(s, s.dyn_ltree, s.dyn_dtree);
                }
                init_block(s);
                if (last) {
                  bi_windup(s);
                }
              }
              function _tr_tally(s, dist, lc) {
                s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 255;
                s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255;
                s.pending_buf[s.l_buf + s.last_lit] = lc & 255;
                s.last_lit++;
                if (dist === 0) {
                  s.dyn_ltree[lc * 2]++;
                } else {
                  s.matches++;
                  dist--;
                  s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;
                  s.dyn_dtree[d_code(dist) * 2]++;
                }
                return s.last_lit === s.lit_bufsize - 1;
              }
              exports3._tr_init = _tr_init;
              exports3._tr_stored_block = _tr_stored_block;
              exports3._tr_flush_block = _tr_flush_block;
              exports3._tr_tally = _tr_tally;
              exports3._tr_align = _tr_align;
            },
            { "../utils/common": 32 },
          ],
          44: [
            function (_dereq_, module3, exports3) {
              "use strict";
              function ZStream() {
                this.input = null;
                this.next_in = 0;
                this.avail_in = 0;
                this.total_in = 0;
                this.output = null;
                this.next_out = 0;
                this.avail_out = 0;
                this.total_out = 0;
                this.msg = "";
                this.state = null;
                this.data_type = 2;
                this.adler = 0;
              }
              module3.exports = ZStream;
            },
            {},
          ],
          45: [
            function (_dereq_, module3, exports3) {
              var root = _dereq_("lodash._root");
              var INFINITY = 1 / 0;
              var symbolTag = "[object Symbol]";
              var reUnescapedHtml = /[&<>"'`]/g,
                reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
              var htmlEscapes = {
                "&": "&amp;",
                "<": "&lt;",
                ">": "&gt;",
                '"': "&quot;",
                "'": "&#39;",
                "`": "&#96;",
              };
              function escapeHtmlChar(chr) {
                return htmlEscapes[chr];
              }
              var objectProto = Object.prototype;
              var objectToString = objectProto.toString;
              var Symbol = root.Symbol;
              var symbolProto = Symbol ? Symbol.prototype : void 0,
                symbolToString = Symbol ? symbolProto.toString : void 0;
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              function isSymbol(value) {
                return (
                  typeof value == "symbol" ||
                  (isObjectLike(value) &&
                    objectToString.call(value) == symbolTag)
                );
              }
              function toString(value) {
                if (typeof value == "string") {
                  return value;
                }
                if (value == null) {
                  return "";
                }
                if (isSymbol(value)) {
                  return Symbol ? symbolToString.call(value) : "";
                }
                var result = value + "";
                return result == "0" && 1 / value == -INFINITY ? "-0" : result;
              }
              function escape(string) {
                string = toString(string);
                return string && reHasUnescapedHtml.test(string)
                  ? string.replace(reUnescapedHtml, escapeHtmlChar)
                  : string;
              }
              module3.exports = escape;
            },
            { "lodash._root": 46 },
          ],
          46: [
            function (_dereq_, module3, exports3) {
              (function (global2) {
                var objectTypes = {
                  function: true,
                  object: true,
                };
                var freeExports =
                  objectTypes[typeof exports3] && exports3 && !exports3.nodeType
                    ? exports3
                    : void 0;
                var freeModule =
                  objectTypes[typeof module3] && module3 && !module3.nodeType
                    ? module3
                    : void 0;
                var freeGlobal = checkGlobal(
                  freeExports &&
                    freeModule &&
                    typeof global2 == "object" &&
                    global2
                );
                var freeSelf = checkGlobal(objectTypes[typeof self] && self);
                var freeWindow = checkGlobal(
                  objectTypes[typeof window] && window
                );
                var thisGlobal = checkGlobal(objectTypes[typeof this] && this);
                var root =
                  freeGlobal ||
                  (freeWindow !== (thisGlobal && thisGlobal.window) &&
                    freeWindow) ||
                  freeSelf ||
                  thisGlobal ||
                  Function("return this")();
                function checkGlobal(value) {
                  return value && value.Object === Object ? value : null;
                }
                module3.exports = root;
              }).call(
                this,
                typeof self !== "undefined"
                  ? self
                  : typeof window !== "undefined"
                  ? window
                  : {}
              );
            },
            {},
          ],
          47: [
            function (_dereq_, module3, exports3) {
              var arrayCopy = _dereq_("lodash._arraycopy"),
                arrayEach = _dereq_("lodash._arrayeach"),
                createAssigner = _dereq_("lodash._createassigner"),
                isArguments = _dereq_("lodash.isarguments"),
                isArray = _dereq_("lodash.isarray"),
                isPlainObject = _dereq_("lodash.isplainobject"),
                isTypedArray = _dereq_("lodash.istypedarray"),
                keys = _dereq_("lodash.keys"),
                toPlainObject = _dereq_("lodash.toplainobject");
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              var MAX_SAFE_INTEGER = 9007199254740991;
              function baseMerge(object, source, customizer, stackA, stackB) {
                if (!isObject(object)) {
                  return object;
                }
                var isSrcArr =
                    isArrayLike(source) &&
                    (isArray(source) || isTypedArray(source)),
                  props = isSrcArr ? void 0 : keys(source);
                arrayEach(props || source, function (srcValue, key) {
                  if (props) {
                    key = srcValue;
                    srcValue = source[key];
                  }
                  if (isObjectLike(srcValue)) {
                    stackA || (stackA = []);
                    stackB || (stackB = []);
                    baseMergeDeep(
                      object,
                      source,
                      key,
                      baseMerge,
                      customizer,
                      stackA,
                      stackB
                    );
                  } else {
                    var value = object[key],
                      result = customizer
                        ? customizer(value, srcValue, key, object, source)
                        : void 0,
                      isCommon = result === void 0;
                    if (isCommon) {
                      result = srcValue;
                    }
                    if (
                      (result !== void 0 || (isSrcArr && !(key in object))) &&
                      (isCommon ||
                        (result === result
                          ? result !== value
                          : value === value))
                    ) {
                      object[key] = result;
                    }
                  }
                });
                return object;
              }
              function baseMergeDeep(
                object,
                source,
                key,
                mergeFunc,
                customizer,
                stackA,
                stackB
              ) {
                var length = stackA.length,
                  srcValue = source[key];
                while (length--) {
                  if (stackA[length] == srcValue) {
                    object[key] = stackB[length];
                    return;
                  }
                }
                var value = object[key],
                  result = customizer
                    ? customizer(value, srcValue, key, object, source)
                    : void 0,
                  isCommon = result === void 0;
                if (isCommon) {
                  result = srcValue;
                  if (
                    isArrayLike(srcValue) &&
                    (isArray(srcValue) || isTypedArray(srcValue))
                  ) {
                    result = isArray(value)
                      ? value
                      : isArrayLike(value)
                      ? arrayCopy(value)
                      : [];
                  } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
                    result = isArguments(value)
                      ? toPlainObject(value)
                      : isPlainObject(value)
                      ? value
                      : {};
                  } else {
                    isCommon = false;
                  }
                }
                stackA.push(srcValue);
                stackB.push(result);
                if (isCommon) {
                  object[key] = mergeFunc(
                    result,
                    srcValue,
                    customizer,
                    stackA,
                    stackB
                  );
                } else if (
                  result === result ? result !== value : value === value
                ) {
                  object[key] = result;
                }
              }
              function baseProperty(key) {
                return function (object) {
                  return object == null ? void 0 : object[key];
                };
              }
              var getLength = baseProperty("length");
              function isArrayLike(value) {
                return value != null && isLength(getLength(value));
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              var merge = createAssigner(baseMerge);
              module3.exports = merge;
            },
            {
              "lodash._arraycopy": 48,
              "lodash._arrayeach": 49,
              "lodash._createassigner": 50,
              "lodash.isarguments": 55,
              "lodash.isarray": 56,
              "lodash.isplainobject": 57,
              "lodash.istypedarray": 59,
              "lodash.keys": 60,
              "lodash.toplainobject": 62,
            },
          ],
          48: [
            function (_dereq_, module3, exports3) {
              function arrayCopy(source, array) {
                var index = -1,
                  length = source.length;
                array || (array = Array(length));
                while (++index < length) {
                  array[index] = source[index];
                }
                return array;
              }
              module3.exports = arrayCopy;
            },
            {},
          ],
          49: [
            function (_dereq_, module3, exports3) {
              function arrayEach(array, iteratee) {
                var index = -1,
                  length = array.length;
                while (++index < length) {
                  if (iteratee(array[index], index, array) === false) {
                    break;
                  }
                }
                return array;
              }
              module3.exports = arrayEach;
            },
            {},
          ],
          50: [
            function (_dereq_, module3, exports3) {
              var bindCallback = _dereq_("lodash._bindcallback"),
                isIterateeCall = _dereq_("lodash._isiterateecall"),
                restParam = _dereq_("lodash.restparam");
              function createAssigner(assigner) {
                return restParam(function (object, sources) {
                  var index = -1,
                    length = object == null ? 0 : sources.length,
                    customizer = length > 2 ? sources[length - 2] : void 0,
                    guard = length > 2 ? sources[2] : void 0,
                    thisArg = length > 1 ? sources[length - 1] : void 0;
                  if (typeof customizer == "function") {
                    customizer = bindCallback(customizer, thisArg, 5);
                    length -= 2;
                  } else {
                    customizer =
                      typeof thisArg == "function" ? thisArg : void 0;
                    length -= customizer ? 1 : 0;
                  }
                  if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                    customizer = length < 3 ? void 0 : customizer;
                    length = 1;
                  }
                  while (++index < length) {
                    var source = sources[index];
                    if (source) {
                      assigner(object, source, customizer);
                    }
                  }
                  return object;
                });
              }
              module3.exports = createAssigner;
            },
            {
              "lodash._bindcallback": 51,
              "lodash._isiterateecall": 52,
              "lodash.restparam": 53,
            },
          ],
          51: [
            function (_dereq_, module3, exports3) {
              function bindCallback(func, thisArg, argCount) {
                if (typeof func != "function") {
                  return identity;
                }
                if (thisArg === void 0) {
                  return func;
                }
                switch (argCount) {
                  case 1:
                    return function (value) {
                      return func.call(thisArg, value);
                    };
                  case 3:
                    return function (value, index, collection) {
                      return func.call(thisArg, value, index, collection);
                    };
                  case 4:
                    return function (accumulator, value, index, collection) {
                      return func.call(
                        thisArg,
                        accumulator,
                        value,
                        index,
                        collection
                      );
                    };
                  case 5:
                    return function (value, other, key, object, source) {
                      return func.call(
                        thisArg,
                        value,
                        other,
                        key,
                        object,
                        source
                      );
                    };
                }
                return function () {
                  return func.apply(thisArg, arguments);
                };
              }
              function identity(value) {
                return value;
              }
              module3.exports = bindCallback;
            },
            {},
          ],
          52: [
            function (_dereq_, module3, exports3) {
              var reIsUint = /^\d+$/;
              var MAX_SAFE_INTEGER = 9007199254740991;
              function baseProperty(key) {
                return function (object) {
                  return object == null ? void 0 : object[key];
                };
              }
              var getLength = baseProperty("length");
              function isArrayLike(value) {
                return value != null && isLength(getLength(value));
              }
              function isIndex(value, length) {
                value =
                  typeof value == "number" || reIsUint.test(value)
                    ? +value
                    : -1;
                length = length == null ? MAX_SAFE_INTEGER : length;
                return value > -1 && value % 1 == 0 && value < length;
              }
              function isIterateeCall(value, index, object) {
                if (!isObject(object)) {
                  return false;
                }
                var type = typeof index;
                if (
                  type == "number"
                    ? isArrayLike(object) && isIndex(index, object.length)
                    : type == "string" && index in object
                ) {
                  var other = object[index];
                  return value === value ? value === other : other !== other;
                }
                return false;
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              module3.exports = isIterateeCall;
            },
            {},
          ],
          53: [
            function (_dereq_, module3, exports3) {
              var FUNC_ERROR_TEXT = "Expected a function";
              var nativeMax = Math.max;
              function restParam(func, start) {
                if (typeof func != "function") {
                  throw new TypeError(FUNC_ERROR_TEXT);
                }
                start = nativeMax(
                  start === void 0 ? func.length - 1 : +start || 0,
                  0
                );
                return function () {
                  var args = arguments,
                    index = -1,
                    length = nativeMax(args.length - start, 0),
                    rest = Array(length);
                  while (++index < length) {
                    rest[index] = args[start + index];
                  }
                  switch (start) {
                    case 0:
                      return func.call(this, rest);
                    case 1:
                      return func.call(this, args[0], rest);
                    case 2:
                      return func.call(this, args[0], args[1], rest);
                  }
                  var otherArgs = Array(start + 1);
                  index = -1;
                  while (++index < start) {
                    otherArgs[index] = args[index];
                  }
                  otherArgs[start] = rest;
                  return func.apply(this, otherArgs);
                };
              }
              module3.exports = restParam;
            },
            {},
          ],
          54: [
            function (_dereq_, module3, exports3) {
              var funcTag = "[object Function]";
              var reIsHostCtor = /^\[object .+?Constructor\]$/;
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              var objectProto = Object.prototype;
              var fnToString = Function.prototype.toString;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var objToString = objectProto.toString;
              var reIsNative = RegExp(
                "^" +
                  fnToString
                    .call(hasOwnProperty)
                    .replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")
                    .replace(
                      /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
                      "$1.*?"
                    ) +
                  "$"
              );
              function getNative(object, key) {
                var value = object == null ? void 0 : object[key];
                return isNative(value) ? value : void 0;
              }
              function isFunction(value) {
                return isObject(value) && objToString.call(value) == funcTag;
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              function isNative(value) {
                if (value == null) {
                  return false;
                }
                if (isFunction(value)) {
                  return reIsNative.test(fnToString.call(value));
                }
                return isObjectLike(value) && reIsHostCtor.test(value);
              }
              module3.exports = getNative;
            },
            {},
          ],
          55: [
            function (_dereq_, module3, exports3) {
              var MAX_SAFE_INTEGER = 9007199254740991;
              var argsTag = "[object Arguments]",
                funcTag = "[object Function]",
                genTag = "[object GeneratorFunction]";
              var objectProto = Object.prototype;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var objectToString = objectProto.toString;
              var propertyIsEnumerable = objectProto.propertyIsEnumerable;
              function baseProperty(key) {
                return function (object) {
                  return object == null ? void 0 : object[key];
                };
              }
              var getLength = baseProperty("length");
              function isArguments(value) {
                return (
                  isArrayLikeObject(value) &&
                  hasOwnProperty.call(value, "callee") &&
                  (!propertyIsEnumerable.call(value, "callee") ||
                    objectToString.call(value) == argsTag)
                );
              }
              function isArrayLike(value) {
                return (
                  value != null &&
                  isLength(getLength(value)) &&
                  !isFunction(value)
                );
              }
              function isArrayLikeObject(value) {
                return isObjectLike(value) && isArrayLike(value);
              }
              function isFunction(value) {
                var tag = isObject(value) ? objectToString.call(value) : "";
                return tag == funcTag || tag == genTag;
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              module3.exports = isArguments;
            },
            {},
          ],
          56: [
            function (_dereq_, module3, exports3) {
              var arrayTag = "[object Array]",
                funcTag = "[object Function]";
              var reIsHostCtor = /^\[object .+?Constructor\]$/;
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              var objectProto = Object.prototype;
              var fnToString = Function.prototype.toString;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var objToString = objectProto.toString;
              var reIsNative = RegExp(
                "^" +
                  fnToString
                    .call(hasOwnProperty)
                    .replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")
                    .replace(
                      /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
                      "$1.*?"
                    ) +
                  "$"
              );
              var nativeIsArray = getNative(Array, "isArray");
              var MAX_SAFE_INTEGER = 9007199254740991;
              function getNative(object, key) {
                var value = object == null ? void 0 : object[key];
                return isNative(value) ? value : void 0;
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              var isArray =
                nativeIsArray ||
                function (value) {
                  return (
                    isObjectLike(value) &&
                    isLength(value.length) &&
                    objToString.call(value) == arrayTag
                  );
                };
              function isFunction(value) {
                return isObject(value) && objToString.call(value) == funcTag;
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              function isNative(value) {
                if (value == null) {
                  return false;
                }
                if (isFunction(value)) {
                  return reIsNative.test(fnToString.call(value));
                }
                return isObjectLike(value) && reIsHostCtor.test(value);
              }
              module3.exports = isArray;
            },
            {},
          ],
          57: [
            function (_dereq_, module3, exports3) {
              var baseFor = _dereq_("lodash._basefor"),
                isArguments = _dereq_("lodash.isarguments"),
                keysIn = _dereq_("lodash.keysin");
              var objectTag = "[object Object]";
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              var objectProto = Object.prototype;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var objToString = objectProto.toString;
              function baseForIn(object, iteratee) {
                return baseFor(object, iteratee, keysIn);
              }
              function isPlainObject(value) {
                var Ctor;
                if (
                  !(
                    isObjectLike(value) &&
                    objToString.call(value) == objectTag &&
                    !isArguments(value)
                  ) ||
                  (!hasOwnProperty.call(value, "constructor") &&
                    ((Ctor = value.constructor),
                    typeof Ctor == "function" && !(Ctor instanceof Ctor)))
                ) {
                  return false;
                }
                var result;
                baseForIn(value, function (subValue, key) {
                  result = key;
                });
                return result === void 0 || hasOwnProperty.call(value, result);
              }
              module3.exports = isPlainObject;
            },
            {
              "lodash._basefor": 58,
              "lodash.isarguments": 55,
              "lodash.keysin": 61,
            },
          ],
          58: [
            function (_dereq_, module3, exports3) {
              var baseFor = createBaseFor();
              function createBaseFor(fromRight) {
                return function (object, iteratee, keysFunc) {
                  var index = -1,
                    iterable = Object(object),
                    props = keysFunc(object),
                    length = props.length;
                  while (length--) {
                    var key = props[fromRight ? length : ++index];
                    if (iteratee(iterable[key], key, iterable) === false) {
                      break;
                    }
                  }
                  return object;
                };
              }
              module3.exports = baseFor;
            },
            {},
          ],
          59: [
            function (_dereq_, module3, exports3) {
              var MAX_SAFE_INTEGER = 9007199254740991;
              var argsTag = "[object Arguments]",
                arrayTag = "[object Array]",
                boolTag = "[object Boolean]",
                dateTag = "[object Date]",
                errorTag = "[object Error]",
                funcTag = "[object Function]",
                mapTag = "[object Map]",
                numberTag = "[object Number]",
                objectTag = "[object Object]",
                regexpTag = "[object RegExp]",
                setTag = "[object Set]",
                stringTag = "[object String]",
                weakMapTag = "[object WeakMap]";
              var arrayBufferTag = "[object ArrayBuffer]",
                dataViewTag = "[object DataView]",
                float32Tag = "[object Float32Array]",
                float64Tag = "[object Float64Array]",
                int8Tag = "[object Int8Array]",
                int16Tag = "[object Int16Array]",
                int32Tag = "[object Int32Array]",
                uint8Tag = "[object Uint8Array]",
                uint8ClampedTag = "[object Uint8ClampedArray]",
                uint16Tag = "[object Uint16Array]",
                uint32Tag = "[object Uint32Array]";
              var typedArrayTags = {};
              typedArrayTags[float32Tag] =
                typedArrayTags[float64Tag] =
                typedArrayTags[int8Tag] =
                typedArrayTags[int16Tag] =
                typedArrayTags[int32Tag] =
                typedArrayTags[uint8Tag] =
                typedArrayTags[uint8ClampedTag] =
                typedArrayTags[uint16Tag] =
                typedArrayTags[uint32Tag] =
                  true;
              typedArrayTags[argsTag] =
                typedArrayTags[arrayTag] =
                typedArrayTags[arrayBufferTag] =
                typedArrayTags[boolTag] =
                typedArrayTags[dataViewTag] =
                typedArrayTags[dateTag] =
                typedArrayTags[errorTag] =
                typedArrayTags[funcTag] =
                typedArrayTags[mapTag] =
                typedArrayTags[numberTag] =
                typedArrayTags[objectTag] =
                typedArrayTags[regexpTag] =
                typedArrayTags[setTag] =
                typedArrayTags[stringTag] =
                typedArrayTags[weakMapTag] =
                  false;
              var objectProto = Object.prototype;
              var objectToString = objectProto.toString;
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function isObjectLike(value) {
                return !!value && typeof value == "object";
              }
              function isTypedArray(value) {
                return (
                  isObjectLike(value) &&
                  isLength(value.length) &&
                  !!typedArrayTags[objectToString.call(value)]
                );
              }
              module3.exports = isTypedArray;
            },
            {},
          ],
          60: [
            function (_dereq_, module3, exports3) {
              var getNative = _dereq_("lodash._getnative"),
                isArguments = _dereq_("lodash.isarguments"),
                isArray = _dereq_("lodash.isarray");
              var reIsUint = /^\d+$/;
              var objectProto = Object.prototype;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var nativeKeys = getNative(Object, "keys");
              var MAX_SAFE_INTEGER = 9007199254740991;
              function baseProperty(key) {
                return function (object) {
                  return object == null ? void 0 : object[key];
                };
              }
              var getLength = baseProperty("length");
              function isArrayLike(value) {
                return value != null && isLength(getLength(value));
              }
              function isIndex(value, length) {
                value =
                  typeof value == "number" || reIsUint.test(value)
                    ? +value
                    : -1;
                length = length == null ? MAX_SAFE_INTEGER : length;
                return value > -1 && value % 1 == 0 && value < length;
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function shimKeys(object) {
                var props = keysIn(object),
                  propsLength = props.length,
                  length = propsLength && object.length;
                var allowIndexes =
                  !!length &&
                  isLength(length) &&
                  (isArray(object) || isArguments(object));
                var index = -1,
                  result = [];
                while (++index < propsLength) {
                  var key = props[index];
                  if (
                    (allowIndexes && isIndex(key, length)) ||
                    hasOwnProperty.call(object, key)
                  ) {
                    result.push(key);
                  }
                }
                return result;
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              var keys = !nativeKeys
                ? shimKeys
                : function (object) {
                    var Ctor = object == null ? void 0 : object.constructor;
                    if (
                      (typeof Ctor == "function" &&
                        Ctor.prototype === object) ||
                      (typeof object != "function" && isArrayLike(object))
                    ) {
                      return shimKeys(object);
                    }
                    return isObject(object) ? nativeKeys(object) : [];
                  };
              function keysIn(object) {
                if (object == null) {
                  return [];
                }
                if (!isObject(object)) {
                  object = Object(object);
                }
                var length = object.length;
                length =
                  (length &&
                    isLength(length) &&
                    (isArray(object) || isArguments(object)) &&
                    length) ||
                  0;
                var Ctor = object.constructor,
                  index = -1,
                  isProto =
                    typeof Ctor == "function" && Ctor.prototype === object,
                  result = Array(length),
                  skipIndexes = length > 0;
                while (++index < length) {
                  result[index] = index + "";
                }
                for (var key in object) {
                  if (
                    !(skipIndexes && isIndex(key, length)) &&
                    !(
                      key == "constructor" &&
                      (isProto || !hasOwnProperty.call(object, key))
                    )
                  ) {
                    result.push(key);
                  }
                }
                return result;
              }
              module3.exports = keys;
            },
            {
              "lodash._getnative": 54,
              "lodash.isarguments": 55,
              "lodash.isarray": 56,
            },
          ],
          61: [
            function (_dereq_, module3, exports3) {
              var isArguments = _dereq_("lodash.isarguments"),
                isArray = _dereq_("lodash.isarray");
              var reIsUint = /^\d+$/;
              var objectProto = Object.prototype;
              var hasOwnProperty = objectProto.hasOwnProperty;
              var MAX_SAFE_INTEGER = 9007199254740991;
              function isIndex(value, length) {
                value =
                  typeof value == "number" || reIsUint.test(value)
                    ? +value
                    : -1;
                length = length == null ? MAX_SAFE_INTEGER : length;
                return value > -1 && value % 1 == 0 && value < length;
              }
              function isLength(value) {
                return (
                  typeof value == "number" &&
                  value > -1 &&
                  value % 1 == 0 &&
                  value <= MAX_SAFE_INTEGER
                );
              }
              function isObject(value) {
                var type = typeof value;
                return !!value && (type == "object" || type == "function");
              }
              function keysIn(object) {
                if (object == null) {
                  return [];
                }
                if (!isObject(object)) {
                  object = Object(object);
                }
                var length = object.length;
                length =
                  (length &&
                    isLength(length) &&
                    (isArray(object) || isArguments(object)) &&
                    length) ||
                  0;
                var Ctor = object.constructor,
                  index = -1,
                  isProto =
                    typeof Ctor == "function" && Ctor.prototype === object,
                  result = Array(length),
                  skipIndexes = length > 0;
                while (++index < length) {
                  result[index] = index + "";
                }
                for (var key in object) {
                  if (
                    !(skipIndexes && isIndex(key, length)) &&
                    !(
                      key == "constructor" &&
                      (isProto || !hasOwnProperty.call(object, key))
                    )
                  ) {
                    result.push(key);
                  }
                }
                return result;
              }
              module3.exports = keysIn;
            },
            { "lodash.isarguments": 55, "lodash.isarray": 56 },
          ],
          62: [
            function (_dereq_, module3, exports3) {
              var baseCopy = _dereq_("lodash._basecopy"),
                keysIn = _dereq_("lodash.keysin");
              function toPlainObject(value) {
                return baseCopy(value, keysIn(value));
              }
              module3.exports = toPlainObject;
            },
            { "lodash._basecopy": 63, "lodash.keysin": 61 },
          ],
          63: [
            function (_dereq_, module3, exports3) {
              function baseCopy(source, props, object) {
                object || (object = {});
                var index = -1,
                  length = props.length;
                while (++index < length) {
                  var key = props[index];
                  object[key] = source[key];
                }
                return object;
              }
              module3.exports = baseCopy;
            },
            {},
          ],
          64: [
            function (_dereq_, module3, exports3) {
              var JSZip, fs, internal;
              JSZip = _dereq_("jszip");
              internal = _dereq_("./internal");
              module3.exports = {
                asBlob: function (html, options) {
                  var zip;
                  zip = new JSZip();
                  internal.addFiles(zip, html, options);
                  return internal.generateDocument(zip);
                },
              };
            },
            { "./internal": 65, jszip: 14 },
          ],
          65: [
            function (_dereq_, module3, exports3) {
              (function (global2, Buffer) {
                var documentTemplate, fs, utils, _;
                documentTemplate = _dereq_("./templates/document");
                utils = _dereq_("./utils");
                _ = {
                  merge: _dereq_("lodash.merge"),
                };
                module3.exports = {
                  generateDocument: function (zip) {
                    var buffer;
                    buffer = zip.generate({
                      type: "arraybuffer",
                    });
                    if (global2.Blob) {
                      return new Blob([buffer], {
                        type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
                      });
                    } else if (global2.Buffer) {
                      return new Buffer(new Uint8Array(buffer));
                    } else {
                      throw new Error(
                        "Neither Blob nor Buffer are accessible in this environment. Consider adding Blob.js shim"
                      );
                    }
                  },
                  renderDocumentFile: function (documentOptions) {
                    var templateData;
                    if (documentOptions == null) {
                      documentOptions = {};
                    }
                    templateData = _.merge(
                      {
                        margins: {
                          top: 1440,
                          // right: 1440,
                          right: 700,
                          bottom: 1440,
                          // left: 1440,
                          left: 700,
                          header: 720,
                          footer: 720,
                          gutter: 0,
                        },
                      },
                      (function () {
                        switch (documentOptions.orientation) {
                          case "landscape":
                            return {
                              height: documentOptions.height || 12240,
                              width: documentOptions.width || 15840,
                              orient: "landscape",
                            };
                          default:
                            return {
                              width: documentOptions.width || 12240,
                              height: documentOptions.height || 15840,
                              orient: "portrait",
                            };
                        }
                      })(),
                      {
                        margins: documentOptions.margins,
                      }
                    );
                    return documentTemplate(templateData);
                  },
                  addFiles: function (zip, htmlSource, documentOptions) {
                    zip.file(
                      "[Content_Types].xml",
                      Buffer(
                        "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8VHlwZXMgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9wYWNrYWdlLzIwMDYvY29udGVudC10eXBlcyI+CiAgPERlZmF1bHQgRXh0ZW5zaW9uPSJyZWxzIiBDb250ZW50VHlwZT0KICAgICJhcHBsaWNhdGlvbi92bmQub3BlbnhtbGZvcm1hdHMtcGFja2FnZS5yZWxhdGlvbnNoaXBzK3htbCIgLz4KICA8T3ZlcnJpZGUgUGFydE5hbWU9Ii93b3JkL2RvY3VtZW50LnhtbCIgQ29udGVudFR5cGU9CiAgICAiYXBwbGljYXRpb24vdm5kLm9wZW54bWxmb3JtYXRzLW9mZmljZWRvY3VtZW50LndvcmRwcm9jZXNzaW5nbWwuZG9jdW1lbnQubWFpbit4bWwiLz4KICA8T3ZlcnJpZGUgUGFydE5hbWU9Ii93b3JkL2FmY2h1bmsubWh0IiBDb250ZW50VHlwZT0ibWVzc2FnZS9yZmM4MjIiLz4KPC9UeXBlcz4K",
                        "base64"
                      )
                    );
                    zip
                      .folder("_rels")
                      .file(
                        ".rels",
                        Buffer(
                          "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8UmVsYXRpb25zaGlwcyB4bWxucz0iaHR0cDovL3NjaGVtYXMub3BlbnhtbGZvcm1hdHMub3JnL3BhY2thZ2UvMjAwNi9yZWxhdGlvbnNoaXBzIj4KICA8UmVsYXRpb25zaGlwCiAgICAgIFR5cGU9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9vZmZpY2VEb2N1bWVudC8yMDA2L3JlbGF0aW9uc2hpcHMvb2ZmaWNlRG9jdW1lbnQiCiAgICAgIFRhcmdldD0iL3dvcmQvZG9jdW1lbnQueG1sIiBJZD0iUjA5YzgzZmFmYzA2NzQ4OGUiIC8+CjwvUmVsYXRpb25zaGlwcz4K",
                          "base64"
                        )
                      );
                    return zip
                      .folder("word")
                      .file(
                        "document.xml",
                        this.renderDocumentFile(documentOptions)
                      )
                      .file("afchunk.mht", utils.getMHTdocument(htmlSource))
                      .folder("_rels")
                      .file(
                        "document.xml.rels",
                        Buffer(
                          "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9InllcyI/Pgo8UmVsYXRpb25zaGlwcyB4bWxucz0iaHR0cDovL3NjaGVtYXMub3BlbnhtbGZvcm1hdHMub3JnL3BhY2thZ2UvMjAwNi9yZWxhdGlvbnNoaXBzIj4KICA8UmVsYXRpb25zaGlwIFR5cGU9Imh0dHA6Ly9zY2hlbWFzLm9wZW54bWxmb3JtYXRzLm9yZy9vZmZpY2VEb2N1bWVudC8yMDA2L3JlbGF0aW9uc2hpcHMvYUZDaHVuayIKICAgIFRhcmdldD0iL3dvcmQvYWZjaHVuay5taHQiIElkPSJodG1sQ2h1bmsiIC8+CjwvUmVsYXRpb25zaGlwcz4K",
                          "base64"
                        )
                      );
                  },
                };
              }).call(
                this,
                typeof self !== "undefined"
                  ? self
                  : typeof window !== "undefined"
                  ? window
                  : {},
                _dereq_("buffer").Buffer
              );
            },
            {
              "./templates/document": 66,
              "./utils": 69,
              buffer: 1,
              "lodash.merge": 47,
            },
          ],
          66: [
            function (_dereq_, module3, exports3) {
              var _ = { escape: _dereq_("lodash.escape") };
              module3.exports = function (obj) {
                var __t,
                  __p2 = "",
                  __j = Array.prototype.join,
                  print = function () {
                    __p2 += __j.call(arguments, "");
                  };
                __p2 +=
                  '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:document\n  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"\n  xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"\n  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"\n  xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"\n  xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"\n  xmlns:ns6="http://schemas.openxmlformats.org/schemaLibrary/2006/main"\n  xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"\n  xmlns:ns8="http://schemas.openxmlformats.org/drawingml/2006/chartDrawing"\n  xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"\n  xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"\n  xmlns:ns11="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"\n  xmlns:dsp="http://schemas.microsoft.com/office/drawing/2008/diagram"\n  xmlns:ns13="urn:schemas-microsoft-com:office:excel"\n  xmlns:o="urn:schemas-microsoft-com:office:office"\n  xmlns:v="urn:schemas-microsoft-com:vml"\n  xmlns:w10="urn:schemas-microsoft-com:office:word"\n  xmlns:ns17="urn:schemas-microsoft-com:office:powerpoint"\n  xmlns:odx="http://opendope.org/xpaths"\n  xmlns:odc="http://opendope.org/conditions"\n  xmlns:odq="http://opendope.org/questions"\n  xmlns:odi="http://opendope.org/components"\n  xmlns:odgm="http://opendope.org/SmartArt/DataHierarchy"\n  xmlns:ns24="http://schemas.openxmlformats.org/officeDocument/2006/bibliography"\n  xmlns:ns25="http://schemas.openxmlformats.org/drawingml/2006/compatibility"\n  xmlns:ns26="http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas">\n  <w:body>\n    <w:altChunk r:id="htmlChunk" />\n    <w:sectPr>\n      <w:pgSz w:w="' +
                  ((__t = obj.width) == null ? "" : __t) +
                  '" w:h="' +
                  ((__t = obj.height) == null ? "" : __t) +
                  '" w:orient="' +
                  ((__t = obj.orient) == null ? "" : __t) +
                  '" />\n      <w:pgMar w:top="' +
                  ((__t = obj.margins.top) == null ? "" : __t) +
                  '"\n               w:right="' +
                  ((__t = obj.margins.right) == null ? "" : __t) +
                  '"\n               w:bottom="' +
                  ((__t = obj.margins.bottom) == null ? "" : __t) +
                  '"\n               w:left="' +
                  ((__t = obj.margins.left) == null ? "" : __t) +
                  '"\n               w:header="' +
                  ((__t = obj.margins.header) == null ? "" : __t) +
                  '"\n               w:footer="' +
                  ((__t = obj.margins.footer) == null ? "" : __t) +
                  '"\n               w:gutter="' +
                  ((__t = obj.margins.gutter) == null ? "" : __t) +
                  '"/>\n    </w:sectPr>\n  </w:body>\n</w:document>\n';
                return __p2;
              };
            },
            { "lodash.escape": 45 },
          ],
          67: [
            function (_dereq_, module3, exports3) {
              var _ = { escape: _dereq_("lodash.escape") };
              module3.exports = function (obj) {
                var __t,
                  __p2 = "",
                  __j = Array.prototype.join,
                  print = function () {
                    __p2 += __j.call(arguments, "");
                  };
                __p2 +=
                  'MIME-Version: 1.0\nContent-Type: multipart/related;\n    type="text/html";\n    boundary="----=mhtDocumentPart"\n\n\n------=mhtDocumentPart\nContent-Type: text/html;\n    charset="utf-8"\nContent-Transfer-Encoding: quoted-printable\nContent-Location: file:///C:/fake/document.html\n\n' +
                  ((__t = obj.htmlSource) == null ? "" : __t) +
                  "\n\n" +
                  ((__t = obj.contentParts) == null ? "" : __t) +
                  "\n\n------=mhtDocumentPart--\n";

                return __p2;
              };
            },
            { "lodash.escape": 45 },
          ],
          68: [
            function (_dereq_, module3, exports3) {
              var _ = { escape: _dereq_("lodash.escape") };
              module3.exports = function (obj) {
                var __t,
                  __p2 = "",
                  __j = Array.prototype.join,
                  print = function () {
                    __p2 += __j.call(arguments, "");
                  };
                __p2 +=
                  "------=mhtDocumentPart\nContent-Type: " +
                  ((__t = obj.contentType) == null ? "" : __t) +
                  "\nContent-Transfer-Encoding: " +
                  ((__t = obj.contentEncoding) == null ? "" : __t) +
                  "\nContent-Location: " +
                  ((__t = obj.contentLocation) == null ? "" : __t) +
                  "\n\n" +
                  ((__t = obj.encodedContent) == null ? "" : __t) +
                  "\n";
                return __p2;
              };
            },
            { "lodash.escape": 45 },
          ],
          69: [
            function (_dereq_, module3, exports3) {
              var mhtDocumentTemplate, mhtPartTemplate;
              mhtDocumentTemplate = _dereq_("./templates/mht_document");
              mhtPartTemplate = _dereq_("./templates/mht_part");
              module3.exports = {
                getMHTdocument: function (htmlSource) {
                  var imageContentParts, _ref;
                  (_ref = this._prepareImageParts(htmlSource)),
                    (htmlSource = _ref.htmlSource),
                    (imageContentParts = _ref.imageContentParts);
                  htmlSource = htmlSource.replace(/\=/g, "=3D");
                  return mhtDocumentTemplate({
                    htmlSource,
                    contentParts: imageContentParts.join("\n"),
                  });
                },
                _prepareImageParts: function (htmlSource) {
                  var imageContentParts, inlinedReplacer, inlinedSrcPattern;
                  imageContentParts = [];
                  inlinedSrcPattern = /"data:(\w+\/\w+);(\w+),(\S+)"/g;
                  inlinedReplacer = function (
                    match,
                    contentType,
                    contentEncoding,
                    encodedContent
                  ) {
                    var contentLocation, extension, index;
                    index = imageContentParts.length;
                    extension = contentType.split("/")[1];
                    contentLocation =
                      "file:///C:/fake/image" + index + "." + extension;
                    imageContentParts.push(
                      mhtPartTemplate({
                        contentType,
                        contentEncoding,
                        contentLocation,
                        encodedContent,
                      })
                    );
                    return '"' + contentLocation + '"';
                  };
                  if (typeof htmlSource === "string") {
                    if (!/<img/g.test(htmlSource)) {
                      return {
                        htmlSource,
                        imageContentParts,
                      };
                    }
                    htmlSource = htmlSource.replace(
                      inlinedSrcPattern,
                      inlinedReplacer
                    );
                    return {
                      htmlSource,
                      imageContentParts,
                    };
                  } else {
                    throw new Error("Not a valid source provided!");
                  }
                },
              };
            },
            { "./templates/mht_document": 67, "./templates/mht_part": 68 },
          ],
        },
        {},
        [64]
      )(64);
    });
  },
});
export default require_html_docx();

/*! Bundled license information:

html-docx-js/dist/html-docx.js:
  (*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
   * @license  MIT
   *)
*/
